def post(self, request):
serializer = ProductoSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return redirect('producto_crear')
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def tienda(self, request, *args, **kwargs):
# id = request.GET["id"
vendedor = request.user.id
productos = Producto.objects.exclude(vendedor=vendedor)
page = self.paginate_queryset(productos)
if page is not None:
serializer = ProductoSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = ProductoSerializer(productos, many=True)
# RegistroBitacora.crearEmpresa(request.user, serializer.data)
return Response({"results": serializer.data},
status=status.HTTP_201_CREATED)
def list(self, request, *args, **kwargs):
user = request.user.profile.id
data = request.query_params
queryset = Producto.objects.filter(vendedor=user, activo=True)
serializer = ProductoSerializer(queryset, many=True)
page = request.GET.get('page')
try:
page = self.paginate_queryset(queryset)
print('page', page)
except Exception as e:
page = []
data = page
return Response({
"status": status.HTTP_404_NOT_FOUND,
"message": 'No more record.',
"data": data
})
if page is not None:
serializer = self.get_serializer(page, many=True)
data = serializer.data
return self.get_paginated_response(data)
return Response(serializer.data, status=status.HTTP_200_OK)
def listadoCatalogoVendedores(self, request):
try:
# Obtener el usuario no registrado
usuarioNoRegistrado = request.user.is_anonymous
print("anonimo: ", usuarioNoRegistrado)
if (usuarioNoRegistrado != True):
# Obtenemos el vendedor
idVendedor = request.user.profile.vendedor_profile
else:
idVendedor = 0
# Obtenemos todos los productos de los otros vendedores excluyendo los productos
# del usuario autenticado
datos = Producto.objects.filter(activo=True).exclude(
vendedor=idVendedor, )
# Especificamos que datos nos va a devolver el serializer
serializer = ProductoSerializer(datos, many=True)
page = request.GET.get("page")
try:
page = self.paginate_queryset(datos)
except Exception as e:
page = []
data = page
#
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
return Response({'detail', str(e)},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk):
prod = get_object_or_404(
Producto,
pk=pk
)
data = ProductoSerializer(prod).data
return Response(data)
def listMyProducts(self, request):
user = request.user
try:
with transaction.atomic():
if user.profile is not None:
queryset = Producto.objects.filter(
activo=True,
profile=user.profile.id
).annotate(
total = models.Sum(
'lote_producto__cantidad',
filter=models.Q(lote_producto__activo=True)
)
)
productos = ProductoSerializer(queryset, many=True)
data = {
"count": len(productos.data),
"results": productos.data
}
return Response({"productos": data}, status=status.HTTP_200_OK)
else:
return Response({"detail": "No envio todos los datos necesarios"}, status=status.HTTP_400_BAD_REQUEST)
return Response({"detail": "Hubo un error al actualizar el producto"}, status=status.HTTP_400_BAD_REQUEST)
except KeyError as e:
return Response({"detail": "{} is a required field".format(str(e))}, status=status.HTTP_400_BAD_REQUEST)
def listProductBySeller(self, request):
data = request.data
try:
with transaction.atomic():
profile = Profile.objects.get(id=data.get("profileId"),
activo=True)
productos = Producto.objects.filter(
profile=data.get("profileId"), activo=True).annotate(
total=models.Sum('lote_producto__cantidad',
filter=models.Q(
lote_producto__activo=True)))
productData = ProductoSerializer(productos, many=True)
user = UserReadSerializer(profile.user)
return Response(
{
"productos": productData.data,
"vendedor": user.data
},
status=status.HTTP_200_OK)
return Response(
{"detail": "Hubo un error al actualizar el producto"},
status=status.HTTP_400_BAD_REQUEST)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
def listByProduct(self, request):
data = request.data
try:
user = request.user
with transaction.atomic():
queryset = Producto.objects.filter(
id=data.get("idProducto"),
activo=True
).prefetch_related(
'lote_producto'
)
producto = ProductoSerializer(queryset[0])
activeLotes = queryset[0].lote_producto.filter(activo=True).order_by('fechaVencimiento')
serializerLote = LoteSerializer(activeLotes, many=True)
lotes = {
"count": queryset[0].lote_producto.count(),
"results": serializerLote.data
}
return Response({"producto": producto.data, "lotes": lotes}, status=status.HTTP_200_OK)
return Response({"detail": "Hubo un error al actualizar el producto"}, status=status.HTTP_400_BAD_REQUEST)
except KeyError as e:
return Response({"detail": "{} is a required field".format(str(e))}, status=status.HTTP_400_BAD_REQUEST)
def catalogo_productos(self, request):
productos = Producto.objects.filter(activo=True)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(productos, request)
serializer = ProductoSerializer(resultado_pagina, many=True)
return paginador.get_paginated_response(serializer.data)
def list(self, request):
user = request.user.id
productos = Producto.objects.filter(usuario=user, activo=True)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(productos, request)
serializer = ProductoSerializer(resultado_pagina, many=True)
return paginador.get_paginated_response(serializer.data)
def mis_productos(self, request, *args, **kwargs):
try:
user = request.user
productos_usuario = Producto.objects.filter(user=user, activo=True)
page = self.paginate_queryset(productos_usuario)
if page is not None:
serializer = ProductoSerializer(page, many=True)
#return Response(serializer.data, status=status.HTTP_200_OK)
return self.get_paginated_response(serializer.data)
except Exception as e:
return Response({'detail': str(e)},
status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
try:
with transaction.atomic():
data = request.data
serializer = ProductoSerializer(data=request.data)
print("imprimiendo", data)
if (serializer.is_valid()):
empresa = None
print("es valido")
if (data.get('idEmpresa').get('__isNew__')):
empresa = Empresa.objects.create(
nombre=data.get('idEmpresa').get('label'))
else:
idEmpresa = data.get('idEmpresa').get('value')
empresa = Empresa.objects.get(pk=idEmpresa)
precio = data.get('precio')
vendedor = request.user.id
vendedorF = User.objects.get(pk=vendedor)
print(precio, vendedorF, "hola")
proyecto = Producto.objects.create(
idEmpresa=empresa,
nombre=data.get('nombre'),
precio=precio,
vendedor=vendedorF,
)
print("holassdf")
proyectoCompleto = ProductoSerializer(proyecto)
# RegistroBitacora.crearEmpresa(request.user, serializer.data)
return Response(proyectoCompleto.data,
status=status.HTTP_201_CREATED)
else:
Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response({'detail': str(e)},
status=status.HTTP_400_BAD_REQUEST)
def listadoProductos(self, request):
try:
# Obtenemos el vendedor
idVendedor = request.user.profile.vendedor_profile
# Obtenemos todos los productos de los otros vendedores exculyendo los productos
# del usuario autenticado
datos = Producto.objects.filter(vendedor=idVendedor, activo=True)
# Especificamos que datos nos va a devolver el serializer
serializer = ProductoSerializer(datos, many=True)
#
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
return Response({'detail', str(e)},
status=status.HTTP_400_BAD_REQUEST)
def infCatalogo(self, request):
try:
# Productos
productos = Producto.objects.all().filter(activo=True)
total_de_productos = User.objects.all().count()
data = {
'productos': ProductoSerializer(productos, many=True).data,
'total_de_productos': total_de_productos
}
return Response(data, status=status.HTTP_200_OK)
except Exception as e:
return Response({'detail': str(e)},
status=status.HTTP_400_BAD_REQUEST)
def totalVentasPorProducto(self, request):
try:
# Obtenemos el vendedor
idVendedor = request.user.profile.vendedor_profile
queryset = Producto.objects.filter(
vendedor=idVendedor, activo=True).annotate(
total_ventas=Sum('compra_producto__total'),
cantidad_vendida=Sum('compra_producto__cantidad'))
# Especificamos que datos nos va a devolver el serializer
serializer = ProductoSerializer(queryset, many=True)
#
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
return Response({'detail', str(e)},
status=status.HTTP_400_BAD_REQUEST)
def resultados(self, request):
data = request.data
user = request.user
try:
with transaction.atomic():
querysetTotal = DetalleVenta.objects.filter(
activo=True,
lote__producto__profile=user.profile.id).aggregate(
total=models.Sum('subtotal'))
querysetPromedio = Producto.objects.filter(
activo=True, profile=user.profile.id).aggregate(
promedio=models.Avg('precioVenta'))
queryPorProducto = Producto.objects.filter(
activo=True,
profile=user.profile.id).annotate(vendido=models.Sum(
'lote_producto__detalleventa_lote__subtotal'))
serializer = ProductoSerializer(queryPorProducto, many=True)
return Response(
{
"total": querysetTotal.get("total"),
"promedioPrecio": querysetPromedio.get("promedio"),
"porProducto": serializer.data
},
status=status.HTTP_200_OK)
return Response(
{"detail": "Hubo un error al actualizar el producto"},
status=status.HTTP_400_BAD_REQUEST)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
def list(self, request, *args, **kwargs):
validacion = request.user.is_anonymous
if (validacion == True):
user = 0
elif (validacion == False):
user = request.user.profile.id
print('USER', user)
data = request.query_params
queryset = Producto.objects.filter(
existencias__gt=0,
activo=True).exclude(vendedor=user).order_by('nombre')
serializer = ProductoSerializer(queryset, many=True)
page = request.GET.get('page')
try:
page = self.paginate_queryset(queryset)
print('page', page)
except Exception as e:
page = []
data = page
return Response({
"status": status.HTTP_404_NOT_FOUND,
"message": 'No more record.',
"data": data
})
if page is not None:
serializer = self.get_serializer(page, many=True)
data = serializer.data
return self.get_paginated_response(data)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
queryset = Producto.objects.all()
serializer = ProductoSerializer(queryset, many=True)
return Response({'productos': serializer.data})
def get(self, request):
prod = Producto.objects.all()[:20]
data = ProductoSerializer(prod, many=True).data
return Response(data)
def get(self, request, format=None):
productos = Producto.objects.all()
serializer = ProductoSerializer(productos, many=True)
return Response(serializer.data)