示例#1
0
def ordenCompraCrea(request):
    message = None
    mess_tipo = 0
    reiniciarSecuencia('PAPELERIA_ITEMS_SQ')
    print "Se reinicio Secuencia"
    if request.method == 'POST':
        proceso = json.loads(request.POST.get('proceso'))
        if 'clienProv' in proceso:
            if len(proceso['producto']) > 0:
                total = 0

                for k in proceso['producto']:
                    precio = Producto.objects.get(id=k['serial']).precio
                    subTotal = precio * int(k['cantidad'])
                    total += subTotal

                crearProceso = Proceso(
                    tipoProceso=TipoProceso.objects.get(id=proceso['tipoPro']),
                    clienteProveedor=ClienteProveedor.objects.get(
                        id=proceso['clienProv']),
                    fecha=timezone.now(),
                    total_facturado=total,
                    empleado=Empleado.objects.get(
                        id=request.user.get_profile().pk))
                crearProceso.save()
                print "proceso guardado"
                print crearProceso.id

                for k in proceso['producto']:
                    crearDetalle = Detalle(
                        item=int(k['item']),
                        producto=Producto.objects.get(id=k['serial']),
                        precio=precio,
                        cantidad=int(k['cantidad']),
                        descuento=Descuento.objects.get(id=int(1)),
                        total=precio * int(k['cantidad']),
                        proceso=crearProceso)
                    crearDetalle.save()
                print "detaller guardado"
                message = 'La Orden de Compra se ha realizado satisfactoriamente'
                mess_tipo = 2
            else:
                message = 'No se ha seleccionado ningun producto'
                mess_tipo = 1
        else:
            message = 'El cliente no ha sido seleccionado'
            mess_tipo = 1
    sqfactura = getValorSecuencia('2')
    return render_to_response('facturacion/crear_orden_compra.html', {
        'message': message,
        'mess_tipo': mess_tipo,
        'sqfactura': sqfactura
    },
                              context_instance=RequestContext(request))
示例#2
0
    def test_C_obtener_proceso_pst(self):
        """
        ¿Obtenemos el proceso del pst ya iniciado?
        ¿Obtenemos el estado del proceso inicial?
        ¿Validamos que el atributo activo sea True?
        ¿El estado que se registro es el correcto?
        ¿Se desactiva el proceso correctamente?
        ¿Se obtiene el proceso iniciado anteriormente cuando ya esta desactivado?
        ¿Se obtiene un solo registro de historial?
        """
        print "## Prueba para metodo obtener_proceso_pst ##"

        self.pst.estatus = ESTATUS_REGISTRO_COMPLETADO
        self.pst.save()

        # Iniciamos varios procesos para un pst
        parametros = Storage(pst=self.pst,
                             nombre_proceso=self.proceso.nombre,
                             observaciones="Vamos a crear una Observacion")
        wf = Workflow(**parametros)
        wf.iniciar()

        data_inicio = Storage(pst=self.pst,
                              nombre_proceso=self.proceso.nombre,
                              cargar="*")
        wf = Workflow(**data_inicio)

        # validamos que el proceso pst no sea none
        self.assertIsNotNone(wf.procesoPst)

        # Validamos si activo es True
        self.assertTrue(wf.procesoPst.activo)

        # Validamos que el estado sea el que iniciamos
        estado = Flujo.objects.get(proceso=self.proceso, inicio=True)
        self.assertEqual(wf.procesoPst.estado, estado)

        # Validamos nombre del estado
        self.assertEqual(wf.procesoPst.nombre_estado, estado.nombre)
        self.assertEqual(wf.nombre_estado, estado.nombre)

        # Desactivamos el proceso anterior
        proceso_viejo = Proceso.objects.get(pk=self.proceso.id)
        proceso_viejo.activo = False
        proceso_viejo.fecha_desactivacion = datetime.now()
        proceso_viejo.save()

        # Verificamos que el proceso de desactivo
        self.assertFalse(proceso_viejo.activo)

        # Verificamos que el que se desactivo sea igual al creado
        self.assertEqual(proceso_viejo.nombre, self.proceso.nombre)
        self.assertEqual(proceso_viejo.id, self.proceso.id)

        # Creamos un proceso nuevo
        data = Storage(
            id=7,
            nombre=self.proceso.nombre,
            descripcion="Esta es una modificacion del proceso prueba",
            activo=True,
            fecha_desactivacion=None)
        proceso_nuevo = Proceso(**data)
        proceso_nuevo.save()

        flujos = [
            Storage(proceso=proceso_nuevo,
                    grupo=self.objGroup[0],
                    nombre="Primer paso",
                    inicio=True,
                    fin=False),
            Storage(proceso=proceso_nuevo,
                    grupo=self.objGroup[1],
                    nombre="Segundo paso",
                    inicio=False,
                    fin=False),
            Storage(proceso=proceso_nuevo,
                    grupo=self.objGroup[0],
                    nombre="Regresando paso uno",
                    inicio=False,
                    fin=False),
            Storage(proceso=proceso_nuevo,
                    grupo=self.objGroup[2],
                    nombre="Tercer paso",
                    inicio=False,
                    fin=False),
            Storage(proceso=proceso_nuevo,
                    grupo=self.objGroup[3],
                    nombre="Cuarto paso fin",
                    inicio=False,
                    fin=True)
        ]

        for fl in flujos:
            f = Flujo(**fl)
            f.save()

        fls = Flujo.objects.filter(proceso=proceso_nuevo)
        fujos_secuencias = [
            Storage(actual=fls[0].id,
                    siguiente=fls[1].id,
                    proceso=proceso_nuevo),
            Storage(actual=fls[1].id,
                    siguiente=fls[2].id,
                    proceso=proceso_nuevo),
            Storage(actual=fls[2].id,
                    siguiente=fls[0].id,
                    proceso=proceso_nuevo),
            Storage(actual=fls[3].id,
                    siguiente=fls[4].id,
                    proceso=proceso_nuevo)
        ]

        for fs in fujos_secuencias:
            f = FlujoSecuencia(**fs)
            f.save()

        # Creamos una instancia con el proceso viejo
        data_vieja = Storage(pst=self.pst,
                             nombre_proceso=proceso_nuevo.nombre,
                             cargar="*")

        # import pdb; pdb.Pdb(skip=['django.*']).set_trace()
        #Creamos una instancia de proceso desactivado
        wf_viejo = Workflow(**data_vieja)
        self.assertEqual(wf_viejo.procesoPst.proceso, proceso_viejo)

        # Existe un solo registro de historial
        self.assertEqual(len(wf_viejo.historial), 1)

        # El historial es obtenido el creado originalmente
        historial = wf_viejo.historial[0]
        estado_inicial = Flujo.objects.get(proceso=wf_viejo.proceso,
                                           inicio=True)
        self.assertIsInstance(historial, HistorialSecuencia)
        self.assertEqual(historial.observaciones, parametros.observaciones)
        self.assertEqual(historial.estado, estado_inicial)
        self.assertEqual(historial.proceso, wf_viejo.proceso)
示例#3
0
    def setUp(self):
        self.wf = None

        # Creamos los datos del proceso para pruebas
        self.p = [
            Storage(id=1,
                    nombre="Prueba",
                    descripcion="esta es una prueba de un proceso",
                    activo=True,
                    fecha_desactivacion=None),
            Storage(id=2,
                    nombre="Prueba Numero Dos",
                    descripcion="esta es una prueba de un proceso",
                    activo=True,
                    fecha_desactivacion=None),
            Storage(id=3,
                    nombre="Prueba Numero Tres",
                    descripcion="esta es una prueba de un proceso",
                    activo=True,
                    fecha_desactivacion=None),
            Storage(id=4,
                    nombre="Prueba",
                    descripcion="esta es una prueba de un proceso version 2",
                    activo=False,
                    fecha_desactivacion=None)
        ]

        self.inactivo = Storage(id=5,
                                nombre="Prueba Inactivo",
                                descripcion="esta es una prueba de un proceso",
                                activo=False,
                                fecha_desactivacion=datetime.now())

        self.sin_flujo = Storage(
            id=6,
            nombre="Prueba Sin flujo",
            descripcion="esta es una prueba de un proceso",
            activo=True,
            fecha_desactivacion=None)

        #Creamos grupos de usuarios
        self.objGroup = []
        grupos = [
            Storage(name="Nombre del grupo uno"),
            Storage(name="Nombre del grupo dos"),
            Storage(name="Nombre del grupo tres"),
            Storage(name="Nombre del grupo cuatro")
        ]
        # Guardamos los datos del proceso y los grupos de usuarios
        self.proceso_inactivo = Proceso(**self.inactivo)
        self.proceso_sin_flujo = Proceso(**self.sin_flujo)
        self.proceso_inactivo.save()
        self.proceso_sin_flujo.save()

        for p in self.p:
            self.proceso = Proceso(**p)
            self.proceso.save()

        for gp in grupos:
            g = Group(**gp)
            g.save()
            self.objGroup.append(g)

        #Asignamos grupos a los usuarios registrados
        users = User.objects.all()[0:4]
        for i, u in enumerate(users):
            u.groups.add(self.objGroup[1 - i])

        # Creamos los datos del flujo para el proceso
        flujos = [
            Storage(proceso=None,
                    grupo=self.objGroup[0],
                    nombre="Primer paso",
                    inicio=True,
                    fin=False),
            Storage(proceso=None,
                    grupo=self.objGroup[1],
                    nombre="Segundo paso",
                    inicio=False,
                    fin=False),
            Storage(proceso=None,
                    grupo=self.objGroup[0],
                    nombre="Regresando paso uno",
                    inicio=False,
                    fin=False),
            Storage(proceso=None,
                    grupo=self.objGroup[2],
                    nombre="Tercer paso",
                    inicio=False,
                    fin=False),
            Storage(proceso=None,
                    grupo=self.objGroup[3],
                    nombre="Cuarto paso fin",
                    inicio=False,
                    fin=True)
        ]

        # Creamos instancias de los objetos y los guardamos
        for p in self.p:
            fls = flujos
            for fl in fls:
                fl.proceso = Proceso.objects.get(pk=p.id)
                f = Flujo(**fl)
                f.save()

        for p in self.p:
            fls = Flujo.objects.filter(proceso=p.id)
            proceso = Proceso.objects.get(pk=p.id)
            fujos_secuencias = [
                Storage(actual=fls[0].id, siguiente=fls[1].id,
                        proceso=proceso),
                Storage(actual=fls[1].id, siguiente=fls[2].id,
                        proceso=proceso),
                Storage(actual=fls[2].id, siguiente=fls[0].id,
                        proceso=proceso),
                Storage(actual=fls[3].id, siguiente=fls[4].id, proceso=proceso)
            ]
            for fs in fujos_secuencias:
                f = FlujoSecuencia(**fs)
                f.save()

        #Obteniendo pst aleatorio para las pruebas
        self.proceso = Proceso.objects.get(
            pk=random.randint(1,
                              len(self.p) - 1))
        random_id = random.randint(1, Pst.objects.count())
        self.pst = Pst.objects.get(id=random_id)
示例#4
0
def facturaCrear(request):
    message = None
    mess_tipo = 0
    #reiniciarSecuencia('PAPELERIA_ITEMS_SQ')
    print "Se reinicio Secuencia"
    if request.method == 'POST':
        form = ProductoForm(request.POST)
        if form.is_valid():
            form.save()
            message = 'La venta se ha realizado satisfactoriamente'
            mess_tipo = 2
        proceso = json.loads(request.POST.get('proceso'))
        if 'clienProv' in proceso:
            if len(proceso['producto']) > 0:
                total = 0

                for k in proceso['producto']:
                    descuento = descProducto(k['cantidad'])
                    p = Producto.objects.get(id=k['serial']).precio
                    ganancia = Producto.objects.get(id=k['serial']).ganancia
                    precio = p + (p * (float(ganancia) / 100))
                    subTotal = (precio * int(k['cantidad'])) - (
                        (precio * int(k['cantidad'])) *
                        (float(descuento) / 100))
                    total += subTotal

                crearProceso = Proceso(
                    tipoProceso=TipoProceso.objects.get(id=proceso['tipoPro']),
                    clienteProveedor=ClienteProveedor.objects.get(
                        id=proceso['clienProv']),
                    fecha=timezone.now(),
                    total_facturado=total,
                    empleado=Empleado.objects.get(
                        id=request.user.get_profile().pk))
                crearProceso.save()
                print "proceso guardado"
                print crearProceso.id

                for k in proceso['producto']:
                    crearDetalle = Detalle(
                        item=int(k['item']),
                        producto=Producto.objects.get(id=k['serial']),
                        precio=p + (p * (float(ganancia) / 100)),
                        cantidad=int(k['cantidad']),
                        descuento=Descuento.objects.get(
                            id=int(descProducto(k['cantidad']))),
                        total=(precio * int(k['cantidad'])) -
                        ((precio * int(k['cantidad'])) *
                         (float(descuento) / 100)),
                        proceso=crearProceso)
                    crearDetalle.save()
                print "detaller guardado"
                print "Proceso numero: ", Proceso.objects.get(
                    id=crearProceso.id).numProceso

                cur = connection.cursor()
                results = cur.callproc('PROCE01', [
                    Proceso.objects.get(id=crearProceso.id).numProceso, 'E',
                    request.user.get_profile().pk, 0
                ])
                cur.close()
                print results
                print "Inventario Actualizado"
                message = 'La venta se ha realizado satisfactoriamente'
                mess_tipo = 2

            else:
                message = 'No se ha seleccionado ningun producto'
                mess_tipo = 1
        else:
            message = 'El cliente no ha sido seleccionado'
            mess_tipo = 1

    else:
        form = ProductoForm()
    sqfactura = getValorSecuencia('1')
    return render_to_response('facturacion/crear_factura.html', {
        'message': message,
        'form': form,
        'mess_tipo': mess_tipo,
        'sqfactura': sqfactura
    },
                              context_instance=RequestContext(request))