def secrets(request):
user_id = request.GET['user']
user = get_object_or_404(User, pk=user_id)
if request.method == strings.POST:
description = request.POST['description']
secret = user.secret_set.create(description=description)
dict = {}
dict[strings.ID] = secret.id
return JsonResponse(dict)
elif request.method == strings.GET:
secrets = Secret.objects.filter(user__id=user.id)
listofsecrets = []
dictofsecrets = {}
for secret in secrets:
listofsecrets.append(
utility.Secret(secret.id, secret.description,
str(secret.pub_date)).__dict__)
dictofsecrets["secrets"] = listofsecrets
return JsonResponse(dictofsecrets)
else:
return JsonError("only can have post and get requests")
def get_documento_firma(request):
if request.method == "POST":
dni = request.POST["data"]
clientes = Clientes.objects.filter(DNI=dni)
pk = -1
if len(clientes) >0:
pk = clientes[0].pk
compras = Compras.objects.filter(Q(vendedor_id=pk) & Q(firma=""))
if len(compras) > 0:
vendedor = compras[0].get_vendedor()
producto = compras[0].producto
return JsonResponse({"result":
[{"nombre": cliente.nombre_completo,
"compra_id": compras[0].id,
"nombre": vendedor["nombre"],
"telefono": vendedor['telefono'],
"DNI": vendedor["DNI"].upper(),
"domicilio": vendedor['domicilio'],
"modelo": str(producto),
"ns_imei": producto.ns_imei,
"precio": producto.precio_compra}]})
else:
return JsonResponse({"result": []})
else:
return JsonError("Solo acepta peticiones POST")
def get_status(request):
if sepuedeVender(request):
return JsonResponse({"result": False})
elif "accion_ventas_dni" in request.session and request.session[
"accion_ventas_dni"] == "ticket":
return JsonResponse({"result": False})
else:
return JsonResponse({"result": True})
def reenviarlinea(request, id, idl, nombre):
import urllib.parse
nombre = urllib.parse.unquote(nombre).replace("+", " ")
pedido = Pedidos.objects.get(pk=id)
camareo = Camareros.objects.get(pk=pedido.camarero_id)
print(pedido.infmesa)
mesa = pedido.infmesa.mesasabiertas_set.get().mesa
lineas = pedido.lineaspedido_set.filter(idart=idl, nombre=nombre).values("idart",
"nombre",
"precio",
"pedido_id").annotate(can=Count('idart'))
receptores = {}
for l in lineas:
receptor = Teclas.objects.get(id=l['idart']).familia.receptor
if receptor.nombre not in receptores:
receptores[receptor.nombre] = {
"op": "urgente",
"hora": pedido.hora,
"receptor": receptor.nomimp,
"camarero": camareo.nombre + " " + camareo.apellidos,
"mesa": mesa.nombre,
"lineas": []
}
l["precio"] = float(l["precio"])
receptores[receptor.nombre]['lineas'].append(l)
send_pedidos_ws(request, receptores)
return JsonResponse({})
def imprimir_ticket(request, id):
ticket = Ticket.objects.get(pk=id)
camarero = Camareros.objects.get(pk=ticket.camarero_id)
lineas = ticket.ticketlineas_set.all().annotate(idart=F("linea__idart"),
precio=F("linea__precio"))
lineas = lineas.values("idart",
"precio").annotate(can=Count('idart'),
totallinea=Sum("precio"))
lineas_ticket = []
for l in lineas:
try:
art = Teclas.objects.get(id=l["idart"])
l["nombre"] = art.nombre
except:
art = ticket.ticketlineas_set.filter(linea__idart=l["idart"])
if len(art) > 0:
l["nombre"] = art[0].linea.nombre
lineas_ticket.append(l)
obj = {
"op": "ticket",
"fecha": ticket.fecha + " " + ticket.hora,
"receptor": Receptores.objects.get(nombre='Ticket').nomimp,
"camarero": camarero.nombre + " " + camarero.apellidos,
"mesa": ticket.mesa,
"lineas": lineas_ticket,
"num": ticket.id,
"efectivo": ticket.entrega,
'total': ticket.ticketlineas_set.all().aggregate(Total=Sum("linea__precio"))['Total']
}
send_ticket_ws(request, obj)
return JsonResponse({})
def send_para_tester(request, id_modelo):
if "accion_comprar_dni" in request.session:
try:
producto = Productos.objects.get(
ns_imei=request.POST.get("ns_imei"))
form = CPProductosForm(request.POST, instance=producto)
except Exception as p:
form = CPProductosForm(request.POST)
if form.is_valid():
producto = form.save(commit=False)
producto.modelo_id = request.session["accion_comprar_pk_modelo"]
producto.estado = "OS"
producto.tipo_id = 1
producto.precio_compra = producto.modelo.precio_usado
producto.save()
request.session["accion_comprar_pk_producto"] = producto.pk
#Guardamos el histarial de la accion Realizada
save_historial(request.user.pk,
request.session["accion_comprar_pk_cliente"],
producto.pk, "Entrada para testeo posible compra")
#Creamos el documento de recepción de terminal.
doc = save_doc_testeo(request.user.pk,
request.session["accion_comprar_pk_cliente"],
producto.pk)
#Guradamos el documen to para firmar
save_doc_firmas(request.user.pk, doc.id, "OS")
vaciar_sesison_compra(request)
return JsonResponse({"result": True})
else:
return redirect("tienda")
def save_complemento(request):
if request.method == "POST":
try:
producto = Productos.objects.get(
ns_imei=request.POST.get("ns_imei"))
except:
producto = Productos()
producto.ns_imei = request.POST["ns_imei"]
producto.detalle = request.POST["detalle"]
producto.precio_venta = request.POST["precio_venta"].replace(",", ".")
producto.es_unico = False
producto.estado = "VT"
producto.save()
compra = Compras(codigo_compra=request.POST["codigo_compra"],
producto_id=producto.id,
usuario_id=request.user.id)
compra.save()
datos = {
"result": True,
"codigo_compra": compra.codigo_compra,
"modelo": unicode(producto),
"ns_imei": producto.ns_imei,
"precio": str(producto.precio_venta),
"tipo": producto.get_descripcion_tipo(),
"descuento": str(producto.descuento),
"es_unico": producto.es_unico
}
return JsonResponse(datos)
return JsonError("Solo puede ser peticiones POST")
def get_all_telf(request):
clientes = Clientes.objects.all().exclude(
Q(telefono="") | Q(telefono=None))
cl_send = []
for c in clientes:
cl_send.append({"telefono": c.telefono})
return JsonResponse(cl_send)
def imprimir_pedido(request, id):
pedido = Pedidos.objects.get(pk=id)
camareo = Camareros.objects.get(pk=pedido.camarero_id)
mesa = pedido.infmesa.mesasabiertas_set.get().mesa
lineas = pedido.lineaspedido_set.values("idart",
"nombre",
"precio",
"pedido_id").annotate(can=Count('idart'))
receptores = {}
for l in lineas:
receptor = Teclas.objects.get(id=l['idart']).familia.receptor
if receptor.nombre not in receptores:
receptores[receptor.nombre] = {
"op": "pedido",
"hora": pedido.hora,
"receptor": receptor.nomimp,
"camarero": camareo.nombre + " " + camareo.apellidos,
"mesa": mesa.nombre,
"lineas": []
}
l["precio"] = float(l["precio"])
receptores[receptor.nombre]['lineas'].append(l)
send_pedidos_ws(request, receptores)
return JsonResponse({})
def register(request):
"""
"username": username
"password": password
"email": email
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
#Username
if not 'username' in data:
return JsonError("'username' is a required field.")
if len(data['username']) < 4 or len(data['username']) > 25:
return JsonError("Usernames must be between 4 and 25 characters.")
if User.objects.filter(username=data['username']).exists():
return JsonError("Username already exists")
if not 'password' in data:
return JsonError("'password' is a required field.")
if len(data['password']) < 5:
return JsonError("A password must be at least 5 characters long.")
if not 'email' in data:
return JsonError("'email' is a required field.")
if len(data['email']) < 5:
return JsonError("Email is too short")
user = User(username=data['username'], email=data['email'])
user.set_password(data['password'])
user.save()
return JsonResponse({"success": True, "data": {"id": user.id}})
def addGrade(request):
"""
courseid: <courseid>
homeworkid: <homeworkid>
optional:
points_received: <# points>
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'courseid' in data:
return JsonError("A courseid field is required to create a grade.")
if not 'homeworkid' in data:
return JsonError("A homeworkid field is required to create a grade.")
if not Course.objects.filter(id=data['courseid']).exists():
return JsonError("The courseid provided for the grade isn't valid.")
if not Homework.objects.filter(id=data['homeworkid']).exists():
return JsonError("The homeworkid provided for the grade isn't valid.")
grade = Grade(course=Course.objects.get(id=data['courseid']),
homework=Homework.objects.get(id=data['homeworkid']),
user=request.user)
if 'points_received' in data:
grade.points_received = data['points_received']
grade.save()
return JsonResponse({"data": {"id": grade.id}, "success": True})
def get_producto(request):
ns_imei = request.POST['ns_imei']
datos = {}
try:
producto = Productos.objects.filter(Q(ns_imei__icontains=ns_imei))
producto = producto[0]
except:
return JsonError("No se ha encontrado coincidencias")
compras = Compras.objects.filter(producto__pk=producto.pk)
if len(compras) > 0:
codigo_compra = compras[0].codigo_compra
else:
codigo_compra = producto.id + 303450
datos = {
"result": True,
"codigo_compra": codigo_compra,
"modelo": unicode(producto),
"ns_imei": producto.ns_imei,
"precio": str(producto.precio_venta),
"tipo": producto.get_descripcion_tipo(),
"descuento": str(producto.descuento),
"es_unico": producto.es_unico,
"estado": producto.estado,
"id": producto.id
}
return JsonResponse(datos)
def addHomework(request):
"""
categoryid: <categoryid>
name: <name>
optional:
points_possible: <# points possible>
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'name' in data:
return JsonError("A name field is required to create a homework.")
if not 'categoryid' in data:
return JsonError(
"A categoryid field is required to create a homework.")
if len(data['name']) < 4:
return JsonError("The name provided for the homework is too short.")
if not Category.objects.filter(id=data['categoryid']).exists():
return JsonError(
"The categoryid provided for the homework isn't valid.")
homework = Homework(name=data['name'],
category=Category.objects.get(id=data['categoryid']))
if 'points_possible' in data:
homework.points_possible = data['points_possible']
homework.save()
return JsonResponse({"data": {"id": homework.id}, "success": True})
def calcular_ingreso(request, fecha=None):
fecha = request.GET["fecha"]
total = 0
if fecha != "":
date = datetime.strptime(fecha, "%d/%m/%Y")
date1 = date + timedelta(days=1)
cajas = Cierrecaja.objects.filter((Q(fecha=date.strftime("%Y/%m/%d"))
& Q(hora__gte='06:00')) |
(Q(fecha=date1.strftime("%Y/%m/%d"))
& Q(hora__lte='05:00')))
for c in cajas:
arq = Arqueocaja.objects.filter(idcierre=c.pk)
descuadre = 0
if len(arq) > 0:
descuadre = arq[0].descuadre
sum = Ticketlineas.objects.filter(Q(idticket__pk__gte=c.ticketcom) &
Q(idticket__pk__lte=c.ticketfinal))
idlineas = sum.values('idlinea')
sum = Lineaspedido.objects.filter(pk__in=idlineas).aggregate(sum_lineas=Sum("precio"))
total = total + (float(sum['sum_lineas']) + descuadre)
return JsonResponse({'total':"%.2f" % total})
def token_new(request):
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
if username and password:
user = authenticate(username=username, password=password)
if user:
if not getattr(user, 'is_active', True):
return JsonResponseForbidden("User account is disabled.")
data = {
'token': token_generator.make_token(user),
'user': user.pk,
}
return JsonResponse(data)
else:
return JsonResponseUnauthorized(
"Unable to log you in, please try again.")
else:
return JsonResponseBadRequest(
"Must include 'username' and 'password' as POST parameters.")
else:
return JsonResponseNotAllowed("Must access via a POST request.")
def token_new(request):
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
if username and password:
user = authenticate(username=username, password=password)
if user:
TOKEN_CHECK_ACTIVE_USER = getattr(settings,
"TOKEN_CHECK_ACTIVE_USER",
False)
if TOKEN_CHECK_ACTIVE_USER and not user.is_active:
return JsonResponseForbidden("User account is disabled.")
data = {
'token': token_generator.make_token(user),
'user': user.pk,
}
return JsonResponse(data)
else:
return JsonResponseUnauthorized(
"Unable to log you in, please try again.")
else:
return JsonError(
"Must include 'username' and 'password' as POST parameters.")
else:
return JsonError("Must access via a POST request.")
def getCategoriesForCourse(request):
response = []
res = check(request)
if res is not None:
return res
data = json.loads(request.body.decode('utf-8'))
course = getObjects(data, Course)
if isError(course):
return course
res = singularOp(course, Course, op="Course2cat")
if res is not None:
return res
coursefil = course[0]
grades = Grade.objects.filter(course=coursefil)
for grade in grades:
response.append(grade.homework.category.id)
# Flatten
response = list(set(response))
responsearr = []
for cid in response:
responsearr.append(Category.objects.filter(id=cid).values()[0])
return JsonResponse({"data": responsearr})
def preimprimir_ticket(request, id):
mesa = Mesasabiertas.objects.get(mesa_id=id)
infmesa = mesa.infmesa
infmesa.numcopias = infmesa.numcopias + 1
infmesa.save()
camareo = infmesa.camarero
mesa = mesa.mesa
lineas = infmesa.lineaspedido_set.filter(estado="P")
lineas = lineas.values("idart", "precio").annotate(can=Count('idart'),
totallinea=Sum("precio"))
lineas_ticket = []
for l in lineas:
try:
art = Teclas.objects.get(id=l["idart"])
l["nombre"] = art.nombre
except:
art = infmesa.lineaspedido_set.filter(idart=l["idart"])
if len(art) > 0:
l["nombre"] = art[0].linea.nombre
lineas_ticket.append(l)
obj = {
"op": "preticket",
"fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
"receptor": Receptores.objects.get(nombre='Ticket').nomimp,
"camarero": camareo.nombre + " " + camareo.apellidos,
"mesa": mesa.nombre,
"numcopias": infmesa.numcopias,
"lineas": lineas_ticket,
'total': infmesa.lineaspedido_set.filter(estado="P").aggregate(Total=Sum("precio"))['Total']
}
send_ticket_ws(request, obj)
return JsonResponse({})
def detail(request, secret_id):
try:
user_id = request.GET['user']
except:
return JsonError("key error")
try:
user = get_object_or_404(User, pk=user_id)
except ObjectDoesNotExist:
return JsonError("User " + user_id + "does not exist")
if request.method == strings.POST:
description = request.POST['description']
try:
selected_secret = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
selected_secret.description = description
selected_secret.save()
return JsonResponse({})
elif request.method == strings.GET:
try:
selected_choice = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
secret = utility.Secret(selected_choice.id,
selected_choice.description,
str(selected_choice.pub_date)).__dict__
return JsonResponse(secret)
elif request.method == strings.DELETE:
try:
selected_secret = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
selected_secret.delete()
return JsonResponse({})
else:
return JsonError("Only can post, put, get, delete")
def save_modelo(request):
from tokenapi.http import JsonResponse, JsonError
f_modelo = ModelosForm(request.POST)
if f_modelo.is_valid():
modelo = f_modelo.save()
return JsonResponse({'id': modelo.id})
else:
return JsonError("formulario no valido")
def abrircajon(request):
obj = {
"op": "open",
"fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
"receptor": Receptores.objects.get(nombre='Ticket').nomimp,
}
send_ticket_ws(request, obj)
return JsonResponse({})
def modificar_precio_venta(request, id_producto):
if request.method == "POST":
producto = Productos.objects.get(pk=id_producto)
producto.estado = "VT"
producto.precio_venta = request.POST["precio_venta"]
producto.save()
return JsonResponse({'precio': producto.precio_venta})
else:
return JsonError("solo peticiones post")
def add(request):
print(request.POST)
print(request.FILES)
exp = Expense.from_receipt(request.FILES['photo'], request.user)
print(exp)
expense = [exp.id, str(exp.date), str(exp.shop), []]
for item in exp.expenseitem_set.all():
expense[-1].append((item.name, str(item.price), item.category))
return JsonResponse(expense)
def qson_django(request):
if request.method != 'POST' or not 'data' in request.POST:
return JsonError("Este servidor solo acepta peticiones POST")
data = json.loads(request.POST.get("data"))
JSONResponse = {}
qson_helper = QSonHelperDjango()
JSONResponse = qson_helper.decode_qson(data)
http = JsonResponse(JSONResponse)
return http
def delete(request, id):
if request.method != "POST":
return JsonError("Only POST is allowed")
post = request.POST
try:
exp = Expense.objects.get(pk=id)
print(exp)
exp.delete()
except Expense.DoesNotExist:
return JsonError("Invalid id")
return JsonResponse({})
def set_firma(request, id_compra, dni):
path_file = os.path.join(settings.BASE_DIR, "firmas/compras")
file_name = "{0}_{1}.jpg".format(dni, id_compra)
file = open(os.path.join(path_file, file_name), "wb")
file_data = request.POST['file']
file_data = base64.b64decode(file_data.split(",")[1])
file.write(file_data)
file.close()
compra = Compras.objects.get(id=id_compra)
compra.firma = file_name
compra.save()
return JsonResponse({"result": True})
def get_review_list(request):
"""
Set review by user
"""
user = request.user
if not user.is_authenticated():
raise PermissionDenied()
reviews = Review.objects.filter(reviewer=user)
review_list = []
for review in reviews:
review_list.append(model_to_dict(review))
return JsonResponse({'status': 'success', 'data': review_list})
def accounts(request):
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
dict = userdict(new_user.id)
return JsonResponse(dict)
else:
return render(request, 'adduser.html', {'form': form})
else:
form = UserForm()
return render(request, 'adduser.html', {'form': form})
def imprimir_desglose(request, id):
arqueo = Arqueocaja.objects.get(pk=id)
cambio = arqueo.cambio
efectivo = arqueo.efectivo_set.all().values("moneda").annotate(can = Sum("can")).order_by("-moneda")
retirar = arqueo.efectivo_set.all().aggregate(total=Sum(F("can") * F("moneda"), output_field=DecimalField()))['total']
retirar = float(retirar) - float(cambio)
lineas_retirada = []
lineas_cambio = []
parcial = 0
for linea in efectivo:
can = linea["can"]
moneda = linea["moneda"]
texto = "moneda" if moneda < 5 else "billete"
texto = texto + "s" if can > 1 else ""
if retirar <= parcial:
if can > 0:
lineas_cambio.append({"titulo": "Cambio", 'can':can,'tipo':float(moneda), 'texto_tipo': texto })
elif retirar > ((can * float(moneda)) + parcial):
parcial = parcial + float((can * moneda))
if can > 0:
lineas_retirada.append({"titulo": "Retirar", 'can':can,'tipo':float(moneda), 'texto_tipo': texto })
else:
diferencia = retirar - parcial
can_parcial = int(diferencia/float(moneda))
parcial = parcial + (can_parcial * float(moneda))
if can_parcial > 0:
lineas_retirada.append({"titulo": "Retirar", 'can':can_parcial,'tipo':float(moneda), 'texto_tipo': texto })
texto = "moneda" if moneda < 5 else "billete"
texto = texto + "s" if can_parcial > 1 else texto
if can - can_parcial > 0:
lineas_cambio.append({"titulo": "Cambio", 'can':can - can_parcial, 'tipo':float(moneda), 'texto_tipo': texto })
obj_cambio = {
"op": "desglose",
"receptor": Receptores.objects.get(nombre='Ticket').nomimp,
"fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
"lineas": lineas_cambio
}
obj_desglose = {
"op": "desglose",
"receptor": Receptores.objects.get(nombre='Ticket').nomimp,
"fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
"lineas": lineas_retirada
}
send_ticket_ws(request, obj_desglose)
send_ticket_ws(request, obj_cambio)
return JsonResponse({})
def token(request, token, user):
try:
user = User.objects.get(pk=user)
except User.DoesNotExist:
return JsonError("User does not exist.")
TOKEN_CHECK_ACTIVE_USER = getattr(settings, "TOKEN_CHECK_ACTIVE_USER",
False)
if TOKEN_CHECK_ACTIVE_USER and not user.is_active:
return JsonError("User account is disabled.")
if token_generator.check_token(user, token):
return JsonResponse({})
else:
return JsonError("Token did not match user.")
