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.")