def chat(self, request, pk):
"""Chat por Cliente."""
obj_api = api()
token = request.session['token']
messages = None
parameters = {'page_size': 0}
data_messages = obj_api.get(slug='queries/clients/' + pk,
token=token,
arg=parameters)
# Ordenamos el listado de mensajes
# para que los mas recientes salgan abajo.
form = QueryForm()
if data_messages:
messages = sorted(data_messages, key=itemgetter('id'))
client = obj_api.get(slug='clients/{}/'.format(pk), token=token)
client_data = {}
client_data["name"] = get_name_by_client(client)
client_data["photo"] = client["photo"]
return render(request, 'frontend/actors/specialist/chat.html', {
'messages': messages,
'form': form,
'client': client_data
})
def detail(self, request, pk):
obj_api = api()
token = request.session['token']
data = obj_api.get_all(slug='backend/matchs/' + pk, token=token)
if data.status_code == 200:
# Titulo de la vista y variables de la Clase
title_page = _('payments').title() + " - " + _('pending').title()
vars_page = self.generate_header(custom_title=title_page)
data_json = data.json()
if request.method == 'POST':
result = obj_api.put_all(slug='confirm-discount/{}'.format(pk),
token=token)
if result and result.status_code == 200:
return HttpResponseRedirect(reverse(self._list))
return render(request, 'admin/authorization/specialist_match.html',
{
'data': data_json,
'vars_page': vars_page
})
else:
return HttpResponseRedirect(reverse(self._list))
def logout_view(request):
if 'token' in request.session:
obj_api = api()
token = request.session['token']
obj_api.logout(token)
logout(request)
return HttpResponseRedirect(reverse('login:login'))
def detail(self, request, pk):
obj_api = api()
token = request.session['token']
data = obj_api.get(slug='specialists/' + pk, token=token)
# Si la data del usuario no es valida
if not data and type(data) is not dict:
raise Http404()
# Si esta definido el tipo de especialista que es el usuario
if type(data) is dict and 'type_specialist' in data:
type_specialist = data['type_specialist']
else:
type_specialist = ''
# Titulo de la vista y variables de la Clase
title_page = "{} {} - {}".format(
_('specialist').title(), _(type_specialist),
_('detail').title())
vars_page = self.generate_header(custom_title=title_page)
return render(request, 'admin/actor/specialistsDetail.html', {
'data': data,
'vars_page': vars_page
})
def send_query(self, request):
"""Enviar data de consulta."""
obj_api = api()
data = json.loads(request.POST.get('query_data'))
token = request.session["token"]
resp = None
import pdb
pdb.set_trace()
if "msg_type" in data["message"][0]:
if "query" in data:
query = data["query"]
if data["message"][0]["msg_type"] == "q":
resp = obj_api.post_all(slug='client/queries/',
token=token,
arg=data)
if data["message"][0]["msg_type"] == "a":
resp = obj_api.put_all(
slug='specialist/queries/{}/'.format(query),
token=token,
arg=data)
if data["message"][0]["msg_type"] == "r":
resp = obj_api.put_all(slug='client/queries/{}/'.format(query),
token=token,
arg=data)
data = resp.json()
data['status_code'] = resp.status_code
return JsonResponse(data)
return JsonResponse({"msg_type": "required"})
def contact_linkup(self, request, pk):
"""Mi contacto Linkup (Vendedor Asignado)."""
obj_api = api()
title_contact = "Tu contacto Linkup"
token = request.session['token']
resp = obj_api.get(slug='sellers/' + pk + "/", token=token)
return render(request, 'frontend/actors/client/my_account.html', {'data_user': resp,
'title_contact': title_contact})
def list_purchase_plans(self, request):
"""Listado de planes."""
obj_api = api()
token = request.session['token']
plans = obj_api.get(slug='plans/', token=token)
return render(request,
'frontend/actors/client/purchase_plan_list.html',
{"plans": plans})
def delete(self, request):
if request.method == 'POST':
id = request.POST['id']
obj_api = api()
result = obj_api.delete(slug='specialists/' + id,
token=request.session['token'])
return JsonResponse({'result': result})
return JsonResponse({})
def index(self, request):
"""Inicio Cliente."""
token = request.session['token']
# import pdb; pdb.set_trace()
obj_api = api()
data_plans = obj_api.get(slug='clients/plans/', token=token, request=request)
# print(data_plans)
# form = ActivePlansForm()
return render(request,
'frontend/actors/client/base_client.html')
def __init__(self,initial=None, token=None, *args, **kwargs):
super(AccountStatusSellerFormFilters, self).__init__(initial, token, *args, **kwargs)
obj_api = api()
# Traer vendedores directamente desde la api
# y actualizamos los options del select
# "?page_size=0" trae un listado, ignorando la paginacion
data = obj_api.get(slug='sellers/?page_size=0', token=token)
if type(data) is list:
self.fields['seller'].widget.choices = [('', '')] + [(l['id'], l['first_name']+' '+l['last_name']) for l in data]
def status(self, request, pk):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='account_status/client/' + pk, token=token)
month_api = resp['mounth']
month = []
for plan in month_api['plans']:
month.append({
"number": plan['query_quantity'],
"text": plan['plan_name']
})
month.append({
"number": plan['queries_used'],
"text": "Consultas absueltas"
})
month.append({
"number": plan['available_queries'],
"text": "Consultas disponibles"
})
month.append({"number": month_api['match_acquired'], "text": "Match"})
month.append({
"number": month_api['match_absolved'],
"text": "Match aceptados"
})
month.append({
"number": month_api['match_declined'],
"text": "Match declinados"
})
historic_api = resp['historic']
historic = []
historic.append({
"number": historic_api['queries_acquired'],
"text": "Consultas adquiridas"
})
historic.append({
"number": historic_api['queries_made'],
"text": "Consultas absueltas"
})
historic.append({
"number": historic_api['queries_available'],
"text": "Consultas disponibles"
})
if month and historic:
return render(request,
'frontend/actors/client/account_status.html', {
'month': month,
'historic': historic
})
else:
return JsonResponse({})
def associates(self, request):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='specialists/associate/', token=token)
associates = resp['results']
count = resp['count']
return render(request,
'frontend/actors/specialist/associate_list.html', {
'associates': associates,
'count': count
})
def middleware(request):
# Code to be executed for each request before
# the view (and later middleware) are called.
if 'token' in request.session:
obj_api = api()
if not obj_api.check_token(request.session['token'], 'oauth/'):
logout(request)
response = get_response(request)
# Code to be executed for each request/response after
# the view is called.
return response
def account_profile(self, request, pk):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='clients/' + pk + "/", token=token)
if resp["type_client"] == 'n':
display_name = resp["first_name"] + ' ' + resp["last_name"]
else:
display_name = resp["agent_firstname"] + ' ' + resp["agent_lastname"]
try:
ciiu = Ciiu.objects.get(pk=resp['ciiu'])
except Ciiu.DoesNotExist:
ciiu = None
return render(request, 'frontend/actors/client/my_account.html', {'data_user': resp, 'ciiu':ciiu, 'name':display_name})
def upload_file(request):
"""Enviar data de archivos."""
obj_api = api()
files = request.FILES
query = request.POST.get('query')
token = request.session["token"]
slug = 'queries/upload_files/{}'.format(query)
resp = obj_api.put_all(slug=slug, token=token, files=files)
if resp.status_code == 200:
return JsonResponse({})
else:
return JsonResponse({"error": resp.status_code})
def account_profile(self, request, pk):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='specialists/' + pk + "/", token=token)
name = resp["first_name"] + ' ' + resp["last_name"]
if resp["type_specialist"] == 'm':
type_specialist = 'Especialista Principal'
else:
type_specialist = 'Especialista Asociado'
if resp:
return render(request, 'frontend/actors/specialist/my_account.html', {'data_user':resp, 'name':name,
'type_specialist': type_specialist})
else:
return JsonResponse({})
def get_user(self, user_id):
"""
Django exige a la clase de autenticacion un metodo
para obtener cualquier usuario por el identificador unico
:param user_id: identificador unico del usuario
:return: objeto User o None
"""
try:
obj_api = api()
# consultar un usuario por el identificador unico
return obj_api.getuserById(user_id)
except User.DoesNotExist:
return None
def summary_purchase_plans(self, request):
"""Resumen compra de planes."""
obj_api = api()
token = request.session['token']
plans_purchase = []
products = []
ids_purchase = []
plans = obj_api.get(slug='plans/', token=token)
ids_plans = request.POST.getlist('vehicle')
total = request.POST["total"]
is_fee = int(request.POST["modality"])
for i in range(0, len(ids_plans)):
id_p = int(ids_plans[i]) - 1
plans_purchase.append(plans[id_p])
for plan in plans_purchase:
id_plan = plan["id"]
plan_name = plan['name']
ids_purchase.append(id_plan)
total_queries = plan['query_quantity']
price = float(plan['price'])
validity = plan['validity_months']
if is_fee == 1:
fee_queries = total_queries // validity
price /= validity
else:
fee_queries = None
products.append({
'id': id_plan,
'name': plan_name,
'total_queries': total_queries,
'fee_queries': fee_queries,
'validity': validity,
'price': price
})
# json_ids = json.loads(ids_purchase)
return render(
request, 'frontend/actors/client/summary_plans.html', {
"products": products,
"total": total,
"isfee": is_fee,
"ids_plans": ids_purchase
})
def authenticate(self, request, username=None, password=None):
"""
A partir del nombre de usuario y password se comprueba
si son los datos correctos por medio de una consulta al api linkup
:param request: request con los datos de username y password
:param username: identificador unico del usuario
:param password: clave del usuario
:return: objeto User si existe el usuario o None si no existe o el password es incorrecto
"""
# crear objeto api
obj_api = api()
# validar datos por medio de una consulta del token del usuario
token = obj_api.token(request.POST['user'], request.POST['password'])
# validar respuesta
if token:
# existe token
# guardar token en la sesion
request.session['token'] = token
try:
# se debe pasar user y token para obtener los datos del usuario
user = obj_api.getUsuario(token, username)
# guardar usuario unicamete para que el framework acepte el objeto
user.save()
# Si es role especialista
if user.role.id == 3:
specialist = obj_api.get_all(
token, slug="specialists-users/{}/".format(username))
if specialist.status_code == 200:
data_specialist = specialist.json()
request.session['specialist'] = {}
request.session['specialist'][
'type_specialist'] = data_specialist[
'type_specialist']
except User.DoesNotExist:
return None
return user
return None
def detail(self, request, pk):
obj_api = api()
data = obj_api.get(slug='sellers/' + pk,
token=request.session['token'])
# Si la data del usuario no es valida
if type(data) is not dict or 'id' not in data:
raise Http404()
# Titulo de la vista y variables de la Clase
title_page = "{} - {}".format(_('Seller').title(), _('detail').title())
vars_page = self.generate_header(custom_title=title_page)
return render(request, 'admin/actor/sellersDetail.html', {
'data': data,
'vars_page': vars_page
})
def list(self, request):
actual_page = get_actual_page(request)
arg = {"page": actual_page}
obj_api = api()
data = obj_api.get(slug='administrators/',
arg=arg,
token=request.session['token'])
custom_column = {
"last_name": {
'type': 'concat',
'data': {'username', 'last_name'}
},
"detail": {
'type': 'detail',
'data': {
'href': 'dashboard:actor-administrators-detail',
'key': 'id'
}
}
}
lastnames_title = "{} {} {}".format(_("surnames"), _("and"),
_("names"))
header_table = {
lastnames_title: "last_name",
_("code"): "code",
_("email"): "email_exact",
_("RUC"): "ruc",
_("category"): "",
_("specialty"): "",
_("detail"): "detail"
}
table = convert(data,
header=header_table,
actual_page=actual_page,
custom_column=custom_column)
vars_page = self.generate_header(
custom_title=_('administrators').title())
return render(request, 'admin/actor/administratorsList.html', {
'table': table,
'vars_page': vars_page
})
def ajax_service(request):
"""Planes Activos."""
obj_api = api()
if request.method == 'PUT':
data = QueryDict(request.body)
else:
data = getattr(request, request.method)
if request.FILES:
files = request.FILES
else:
files = None
if 'use_method' in data:
request.method = data['use_method']
if 'url' in data:
url = data['url']
else:
return JsonResponse()
if 'token' in request.session:
token = request.session['token']
else:
token = None
data = clean_data_files(request, data)
if 'serialize' in data:
data = serialize_keystr_to_json(request, data, data["serialize"])
resp = getattr(obj_api,
request.method.lower() + '_all')(slug=url,
token=token,
arg=data,
files=files)
data = resp.json()
try:
data['status_code'] = resp.status_code
except TypeError as e:
print(e)
return JsonResponse(data, safe=False)
def associate(self, request, pk):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='specialists/' + pk, token=token)
data_user = resp
name = data_user['first_name'] + ' ' + data_user['last_name']
type_specialist = data_user['type_specialist']
if type_specialist == 'a':
type_specialist = 'Especialista asociado'
elif type_specialist == 'm':
type_specialist = 'Especialista principal'
return render(
request, 'frontend/actors/specialist/my_account.html', {
'data_user': data_user,
'type_specialist': type_specialist,
'name': name
})
def detail(self, request, pk):
obj_api = api()
token = request.session['token']
data = obj_api.get_all(slug='backend/matchs/' + pk, token=token)
if data.status_code == 200:
# Titulo de la vista y variables de la Clase
title_page = _('payments').title() + " - " + _('pending').title()
vars_page = self.generate_header(custom_title=title_page)
data_json = data.json()
if request.method == 'POST':
form = PaymentMatch(data=request.POST)
if form.is_valid():
data = form.cleaned_data
result = obj_api.post_all(
slug='specialists/payment/match/',
token=token,
arg=data)
if result and result.status_code == 201:
return HttpResponseRedirect(reverse(self._list))
else:
# Mostrar Errores en Form
# Agregamos errores retornados por la app para este formulario
form.add_error_custom(add_errors=result.json())
else:
payment = {}
payment['bank'] = 1
payment['match'] = data_json['id']
form = PaymentMatch(initial=payment)
return render(
request, 'admin/payment/match.html', {
'data': data_json,
'vars_page': vars_page,
'form': form,
'go_back': self._list
})
else:
return HttpResponseRedirect(reverse(self._list))
def chat(self, request, pk):
"""Chat por Especialidad."""
obj_api = api()
token = request.session['token']
messages = None
parameters = {'page_size': 0}
data_messages = obj_api.get(slug='queries/categories/' + pk,
token=token,
arg=parameters)
# Ordenamos el listado de mensajes para que los mas recientes salgan
# abajo.
esp = Category.objects.get(pk=pk)
form = QueryForm()
if data_messages:
messages = sorted(data_messages, key=itemgetter('id'))
return render(request, 'frontend/actors/client/chat.html', {
'messages': messages,
'form': form,
'speciality': esp
})
def create(self, request):
"""Metodo para crear Vendedores."""
obj_api = api()
token = request.session["token"]
# Si llega envio por POST se valida contra el SpecialistForm
if request.method == 'POST':
form = self.generate_form_seller(data=request.POST,
files=request.FILES)
if form.is_valid():
# Tomamos todo el formulario para enviarlo a la API
data = form.cleaned_data
data.update({
"address": {
"street": data["street"],
"department": data["department"],
"province": data["province"],
"district": data["district"],
},
"username": data["email_exact"]
})
result = obj_api.post(slug='sellers/', token=token, arg=data)
if result and 'id' in result:
if 'photo' in request.FILES:
photo = {'photo': request.FILES['photo']}
obj_api.put(slug='upload_photo/' + str(result['id']),
token=token,
files=photo)
# Process success
if 'img_document_number' in request.FILES:
img_document_number = {
'img_document_number':
request.FILES['img_document_number']
}
obj_api.put(slug='upload_document/' +
str(result['id']),
token=token,
files=img_document_number)
# Process success
return HttpResponseRedirect(reverse(self._list))
else:
# Mostrar Errores en Form
form.add_error_custom(
add_errors=result
) # Agregamos errores retornados por la app para este formulario
return render(request, 'admin/actor/sellersForm.html',
{'form': form})
else:
# Crear formulario de especialistas vacio, se traeran
# datos de selecion como Categorias y Departamentos.
form = self.generate_form_seller()
title_page = _('create seller').title()
vars_page = self.generate_header(custom_title=title_page)
sellers_form = reverse(self._create)
return render(request, 'admin/actor/sellersForm.html', {
'vars_page': vars_page,
'form': form,
'sellers_form': sellers_form
})
def register(request):
"""
Vista para generar formulario de Registro perona Nutaral o Juridica
"""
obj_api = api()
type_client = 'n'
if 'type_client' in request.GET:
type_client = request.GET['type_client']
if request.method == 'POST':
if type_client == 'n':
# Crear formulario de registro para persona Natural
form = RegisterClientFormNatural(
data=request.POST,
files=request.FILES,
initial={'type_client': type_client})
template = 'public/register_natural.html'
else:
# Crear formulario de registro para persona Juridica
form = RegisterClientFormBusiness(
data=request.POST,
files=request.FILES,
initial={'type_client': type_client})
template = 'public/register_business.html'
if form.is_valid():
# Tomamos todo el formulario para enviarlo a la API
data = form.cleaned_data
data.update({
"address": {
"street": data["street"],
"department": data["department"],
"province": data["province"],
"district": data["district"],
}
})
data['username'] = data['email_exact']
tools = Tools()
if 'birthdate' in data:
data['birthdate'] = tools.date_format_to_db(
date=data['birthdate'])
result = obj_api.post(slug='clients/', arg=data)
# Si la respuesta de la API fue exitosa
if result and 'id' in result:
if 'photo' in request.FILES:
photo = {'photo': request.FILES['photo']}
image = Image.open(
os.path.join(BASE_DIR,
request.FILES['photo'].file.name))
width, height = image.size
if width > height:
factor = 512 / width
else:
factor = 512 / height
img = image.resize(
(int(width * factor), int(height * factor)))
# image.size
# import pdb; pdb.set_trace()
img.save(request.FILES['photo'].file.name,
image.format,
quality=95)
obj_api.put(slug='upload_photo/' + str(result['id']),
files=photo) # Envio de foto del Cliente
# Process success
template = 'public/register_success.html'
else:
# Mostrar Errores en Form
# Agregamos errores retornados por la app para este formulario
form.add_error_custom(add_errors=result)
else:
if type_client == 'n':
# Crear formulario de registro para persona Natural
form = RegisterClientFormNatural(
initial={'type_client': type_client})
template = 'public/register_natural.html'
else:
# Crear formulario de registro para persona Juridica
form = RegisterClientFormBusiness(
initial={'type_client': type_client})
template = 'public/register_business.html'
return render(request, template, {'form': form})
def edit(self, request, pk):
obj_api = api()
token = request.session['token']
if request.method == 'POST':
form = self.generate_form_seller(data=request.POST,
form_edit=True,
files=request.FILES)
# check whether it's valid:
if form.is_valid():
# Tomamos todo el formulario para enviarlo a la API
data = form.cleaned_data
data.update({
"address": {
"street": data["street"],
"department": data["department"],
"province": data["province"],
"district": data["district"],
}
})
# return JsonResponse(data)
result = obj_api.put(slug='sellers/' + pk,
token=token,
arg=data)
if result and 'id' in result:
# Agregando foto del Usuario
if 'photo' in request.FILES:
photo = {'photo': request.FILES['photo']}
obj_api.put(slug='upload_photo/' + pk,
token=token,
files=photo)
# Se agrega documento del usuario
if 'img_document_number' in request.FILES:
img_document_number = {
'img_document_number':
request.FILES['img_document_number']
}
obj_api.put(slug='upload_document/' + pk,
token=token,
files=img_document_number)
return HttpResponseRedirect(reverse(self._list))
else:
# Mostrar Errores en Form
form.add_error_custom(
add_errors=result
) # Agregamos errores retornados por la app para este formulario
return render(request, 'admin/actor/sellersForm.html',
{'form': form})
else:
seller = obj_api.get(slug='sellers/' + pk, token=token)
form = self.generate_form_seller(seller=seller, form_edit=True)
title_page = _('edit seller').title()
vars_page = self.generate_header(custom_title=title_page)
sellers_form = reverse(self._edit, args=(pk, ))
return render(request, 'admin/actor/sellersForm.html', {
'vars_page': vars_page,
'form': form,
'sellers_form': sellers_form
})
def status(self, request, pk):
obj_api = api()
token = request.session['token']
resp = obj_api.get(slug='account_status/specialist/' + pk, token=token)
month_api = resp['mounth']
month = []
month.append({
"number": month_api['queries_category_total'],
"text": "Consultas recibidas"
})
month.append({
"number": month_api['queries_category_absolved'],
"text": "Consultas absueltas"
})
month.append({
"number": month_api['queries_category_pending'],
"text": "Consultas pendientes"
})
if resp['type_specialist'] == 'm':
month.append({
"number": month_api['queries_main_total'],
"text": "Especialista principal"
})
month.append({
"number": month_api['queries_main_absolved'],
"text": "Principal absueltas"
})
month.append({
"number": month_api['queries_main_pending'],
"text": "Principal pendientes"
})
month.append({
"number": month_api['queries_asociate_total'],
"text": "Especialistas asociados"
})
month.append({
"number": month_api['queries_asociate_absolved'],
"text": "Asociados absueltas"
})
month.append({
"number": month_api['queries_asociate_pending'],
"text": "Asociados pendientes"
})
month.append({"number": month_api['match_total'], "text": "Match"})
month.append({
"number": month_api['match_accepted'],
"text": "Match aceptados"
})
month.append({
"number": month_api['match_declined'],
"text": "Match declinados"
})
historic_api = resp['historic']
historic = []
historic.append({
"number": historic_api['queries_main_absolved'],
"text": "Consultas absueltas"
})
historic.append({
"number": historic_api['match_accepted'],
"text": "Match aceptados"
})
if resp:
return render(request,
'frontend/actors/client/account_status.html', {
'month': month,
'historic': historic
})
else:
return JsonResponse({})
def list(self, request):
"""
Listado de estado de cuenta de vendedores, donde se debera filtrar para buscar
las ventas de un vendedor en especifico.
"""
table = data_user = ""
obj_api = api()
token = request.session['token']
title_page = _('Seller').title()
form_filters = AccountStatusSellerFormFilters(initial=request.GET, token=token)
if form_filters.is_valid():
filters = form_filters.cleaned_data
pk = filters['seller']
if pk:
actual_page = None
tools = Tools()
filters['from_date'] = tools.date_format_to_db(date=filters['from_date'])
filters['until_date'] = tools.date_format_to_db(date=filters['until_date'])
if filters['show_sum_column']:
filters['page_size'] = 0
else:
actual_page = get_actual_page(request)
# Traer data para el listado
data = obj_api.get(slug='account_status/sellers/' + pk, arg=filters, token=token)
# Columnas personalizadas, tienen mayor prioriedad que los campos que retornan de la api
custom_column = {
"purchase__fee__date": {'type': 'date', 'data': ('purchase__fee__date',)},
"fee_accumulated": {'type': 'format_price', 'data': ('fee_accumulated',)},
"purchase__fee__fee_amount": {'type': 'format_price', 'data': ('purchase__fee__fee_amount',)},
"purchase__total_amount": {'type': 'format_price', 'data': ('purchase__total_amount',)},
"amount_accumulated": {'type': 'format_price', 'data': ('amount_accumulated',)},
"pending_payment": {'type': 'eval',
'data': ('float(r["purchase__total_amount"]) - float(r["fee_accumulated"])',),
'next': {'type': 'format_price'}},
"count_products_c": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])<=1',),
'next': {'type': 'concat', 'data': ('count_products',)}},
"fee_accumulated_c": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])<=1',),
'next': {'type': 'concat', 'data': ('fee_accumulated',)}},
"purchase__fee__fee_amount_c": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])<=1',),
'next': {'type': 'concat', 'data': ('purchase__fee__fee_amount',)}},
"amount_accumulated_c": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])<=1',),
'next': {'type': 'concat', 'data': ('amount_accumulated',)}},
"count_products_q": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])>1',),
'next': {'type': 'concat', 'data': ('count_products',)}},
"fee_accumulated_q": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])>1',),
'next': {'type': 'concat', 'data': ('fee_accumulated',)}},
"purchase__fee__fee_amount_q": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])>1',),
'next': {'type': 'concat', 'data': ('purchase__fee__fee_amount',)}},
"amount_accumulated_q": {'type': 'if_eval', 'data': ('int(r["purchase__fee_number"])>1',),
'next': {'type': 'concat', 'data': ('amount_accumulated',)}},
"purchase_fee_amount": {'type': 'concat', 'data': ('purchase__fee__fee_amount',)},
"purchase__fee__reference_number": {'type': 'concat', 'data': (
'purchase__fee__fee_order_number', '/', 'purchase__fee_number')},
}
# Cabecera principal, los titulos de la columna seran sobrepuestos si pasa el list de cabecera multiple
header_table = [(_("date"), "purchase__fee__date"), (_("type"), "is_billable"), (
_("number"), "purchase__code"), (_("code"), "purchase__client__code"),
(_("nick"), "purchase__client__nick"), (
_("name"), "purchase__product__name"),
(_("query amount"), "purchase__query_amount"), (
_("mounth of duration"), "purchase__product__expiration_number"), (
_("price"), "purchase__total_amount"), (_("Payments Made"), "purchase_fee_amount"),
(
_("Pending payment"), "pending_payment"), (
_("advance"), "purchase__fee__reference_number"), (
"", "count_products_c"), ("", "fee_accumulated_c"),
("", "purchase__fee__fee_amount_c"), ("", "amount_accumulated_c"), (
"", "count_products_q"), ("", "fee_accumulated_q"),
("", "purchase__fee__fee_amount_q"), ("", "amount_accumulated_q"), (
"", "count_products"), ("", "fee_accumulated"), ("", "purchase__fee__fee_amount"),
("", "amount_accumulated")]
# Multiples header, una lista por cada nivel de la cabecera
multi_header = [
[
(_('date'), {'rowspan': '4'}),
(_('reference of sale'), {'rowspan': '3', 'colspan': '2'}),
(_('customer reference'), {'rowspan': '3', 'colspan': '2'}),
(_('description of plans'), {'rowspan': '3', 'colspan': '3'}),
(_('sales productivity'), {'rowspan': '3', 'colspan': '4'}),
(_('Composition of the Sale by Form of Payment'), {'rowspan': '1', 'colspan': '12'}),
],
[
(_('Cash'), {'colspan': '4'}),
(_('Credit'), {'colspan': '4'}),
(_('Totals'), {'colspan': '4'}),
],
[
(_('units'), {'colspan': '2'}),
(_('amount'), {'colspan': '2'}),
(_('units'), {'colspan': '2'}),
(_('amount'), {'colspan': '2'}),
(_('units'), {'colspan': '2'}),
(_('amount'), {'colspan': '2'}),
],
[
(_('type'), {}),
(_('number'), {}),
(_('code'), {}),
(_('Nick'), {}),
(_('name'), {}),
(_('N° of queries'), {}),
(_('mounth of duration'), {}),
(_('Price'), {}),
(_('Payments Made'), {}),
(_('Pending payment'), {}),
(_("reference fee"), {}),
(_('quantity'), {}),
(_('accumulated'), {}),
(_('paid out'), {}),
(_('accumulated'), {}),
(_('quantity'), {}),
(_('accumulated'), {}),
(_('paid out'), {}),
(_('accumulated'), {}),
(_('quantity'), {}),
(_('accumulated'), {}),
(_('paid out'), {}),
(_('accumulated'), {}),
],
]
if filters['show_sum_column']:
# Lista con los valores para el footer de la tabla, posterior al cargado de la data
footer = [
{
'purchase__total_amount': {'type': 'acum', 'id': 'purchase__id',
'value': 'purchase__total_amount', 'format_price': True},
'purchase_fee_amount': {'type': 'acum', 'id': 'purchase__fee__id',
'value': 'purchase__fee__fee_amount', 'format_price': True},
'pending_payment': {'type': 'eval',
'data': 'float(f[0]["_purchase__total_amount"])-float(f[0]["_purchase_fee_amount"])',
'format_price': True},
},
{
'purchase_fee_amount': {'type': 'eval',
'data': 'float(f[0]["_purchase_fee_amount"])/float(f[0]["_purchase__total_amount"])',
'format_price': True},
'pending_payment': {'type': 'eval', 'data': '1-float(f[1]["_purchase_fee_amount"])',
'format_price': True},
}
]
else:
footer = None
table = convert(data, header=header_table, actual_page=actual_page, custom_column=custom_column,
multi_header=multi_header, footer=footer)
data_user = obj_api.get(slug='sellers/' + pk, token=token)
vars_page = self.generate_header(custom_title=title_page)
return render(request, 'admin/account_status/account_status_seller.html',
{'vars_page': vars_page, 'table': table, 'form_filters': form_filters, 'data_user': data_user})
