Пример #1
0
def remisionCompraCrea(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'))
		print 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),
					remision = Proceso.objects.get(id=proceso['orden'])
					)
				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"
				print "Proceso numero: " , Proceso.objects.get(id=crearProceso.id).numProceso
				
				cur = connection.cursor()
				results = cur.callproc('PROCE01', [Proceso.objects.get(id=crearProceso.id).numProceso, 'I', 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
	sqfactura = getValorSecuencia('3')
	return render_to_response('facturacion/crear_remision_compra.html', {'message': message, 'mess_tipo': mess_tipo, 'sqfactura': sqfactura}, context_instance=RequestContext(request))
Пример #2
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))
Пример #3
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)
Пример #4
0
class WorkflowTest(TestCase):
    """Implementando pruebas unitarias para la clase Workflow """

    fixtures = [
        'fixtures/000_tipo_pst.json', 'fixtures/001_cuentas_pst.json',
        'fixtures/002_registro_pst_inicial.json'
    ]

    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)

    def test_A_validar_datos(self):
        """
        ¿Validando que se crearon los procesos para prueba?
        ¿Valida que el tipo de dato pst sea un Objeto pst?
        ¿Valida que el que el pst tenga estado de registro completado?
        ¿Valida que el proceso solicitado exista?
        ¿Se crea correctamente la instancia del Workflow?
        """
        print "## Prueba para metodo validar_datos ##"

        # Validando que se crearon los datos de prueba
        self.assertEqual(FlujoSecuencia.objects.count(), 16)
        self.assertEqual(Flujo.objects.count(), 20)

        # Validando que el parametro pst se instancia Pst
        with self.assertRaisesRegexp(
                NameError,
                'Error de Tipo. El atributo pst debe ser una instancia Pst'):
            wf = Workflow(int(), self.proceso.nombre)

        # Validando estado de registro del pst
        with self.assertRaisesRegexp(
                NameError,
                'Error de Estado. El Pst debe tener un estado de registro completado'
        ):
            wf = Workflow(self.pst, self.proceso.nombre)

        # Cambiamos estado del pst
        self.pst.estatus = ESTATUS_REGISTRO_COMPLETADO
        self.pst.save()

        # Validando que exista el proceso
        with self.assertRaisesRegexp(
                NameError,
                'Error de Registro. El proceso que solicito no esta registrado o activo'
        ):
            wf = Workflow(self.pst, '2')

        with self.assertRaisesRegexp(
                NameError,
                'Error de Registro. El proceso que solicito no esta registrado o activo'
        ):
            wf = Workflow(self.pst, self.inactivo.nombre)

        with self.assertRaisesRegexp(
                NameError,
                'Error de Registro. No hay Flujos registrados para el proceso Iniciado'
        ):
            wf = Workflow(self.pst, self.sin_flujo.nombre)

        # Creando instancia Workflow
        wf = Workflow(self.pst, self.proceso.nombre)
        self.assertIsNotNone(wf)

    def test_B_iniciar(self):
        """
        ¿Se inicia el proceso correctamente?
        ¿El ProcesoPst iniciado es igual que el proceso creado?
        ¿Se pueden crear dos procesos para el mismo pst con el mismo nombre?
        ¿Se crea el historial para el Proceso Pst iniciado?
        ¿El estado de proceso es el inicial?
        ¿El nombre del estado es el correcto?
        ¿Esta activo el proceso en procesoPst?
        ¿Se creo el historial para el inicio del proceso?
        ¿Verificamos que el historial sea una instancia de HistorialSecuencia?
        ¿El historial es igual al del proceso iniciado?
        ¿Se registro la observacion correctamente?
        ¿El historial tiene usuario asignado?
        ¿El usuario de historial es una instancia de MinturUser?
        """
        print "## Prueba para metodo iniciar ##"

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

        # Creando instancia Workflow
        parametros = Storage(pst=self.pst,
                             nombre_proceso=self.proceso.nombre,
                             observaciones="Observaciones para registro")

        wf = Workflow(**parametros)
        proceso_test = Proceso.objects.get(nombre__exact=self.proceso.nombre,
                                           activo=True)

        # Verificamos el inicio del proceso correctamente
        proceso_pst = wf.iniciar()
        self.assertIsNotNone(proceso_pst)

        # Verificamos que el proceso no se inicie nuevamente
        with self.assertRaisesRegexp(
                NameError,
                'Error de operacion. Ya se ha iniciado el proceso para el Pst indicado'
        ):
            wf.iniciar()

        # Verificamos que el procesoPst iniciado sea igual al proceso Creado
        self.assertEqual(proceso_test, proceso_pst.proceso)

        # #Verificamos que se creo el
        historial = HistorialSecuencia.objects.get(proceso_pst=proceso_pst)
        self.assertIsNotNone(historial)

        # #Verificamos que el estado creado sea el inicial
        estado = Flujo.objects.get(proceso=proceso_test, inicio=True)
        self.assertIsNotNone(estado)
        self.assertEqual(historial.estado, estado)

        # Creamos un nueva instancia de Workflow
        data = Storage(pst=self.pst,
                       nombre_proceso=self.proceso.nombre,
                       cargar="*")
        wf = Workflow(**data)

        # Verificamos si el proceso esta activo
        self.assertTrue(wf.procesoPst.activo)

        # Verificamos si se creo el historial
        self.assertEqual(len(wf.historial), 1)

        # Validamos que sea una instancia de historial
        historial = wf.historial[0]
        self.assertIsInstance(historial, HistorialSecuencia)

        # Validamos que el primer registro sea del estado correcto
        self.assertEqual(historial.estado, estado)

        # El Historial creado es del proceso_pst correcto
        proceso_pst = ProcesoPst.objects.get(pst=self.pst,
                                             proceso=self.proceso)
        self.assertEqual(historial.proceso_pst, proceso_pst)

        # Validamos que se guardo las observaciones correctamente
        self.assertEqual(historial.observaciones, parametros.observaciones)

        # Validamos que el usuario que creo no sea nulo
        self.assertIsNotNone(historial.user)

        # Validamos que sea una instancia de MinturUser
        self.assertIsInstance(historial.user, User)

    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)

    def test_D_actualizar(self):
        """
        ¿Se puede actualizar el proceso que no se ha iniciado?
        ¿Un pst puede tener dos procesos activos del mismo tipo?
        ¿Se actualiza correctamente el proceso iniciado?
        ¿El estado actualizado es el correcto?
        ¿El flujo secuencia es el correcto?
        ¿La cantidad del historial creada es la misma cantidad registrada?
        ¿El historial se creo correctamente?
        ¿El primer registro del historial es de la secuencia inicial?
        ¿El historial creado es del proceso indicado?
        ¿El segundo registro del historial es de la secuencia actualizada?
        ¿El el historial del procesoPst sea el correspondiente?
        ¿Se Registro correctamente las observaciones?
        ¿Se Finalizo el proceso correctamente?
        ¿Se registro el historial de finalizacion?
        """
        print "## Prueba para metodo actualizar ##"

        estado = Flujo.objects.filter(proceso=self.proceso)[1]
        self.pst.estatus = ESTATUS_REGISTRO_COMPLETADO
        self.pst.save()

        parametros_iniciales = Storage(
            pst=self.pst,
            nombre_proceso=self.proceso.nombre,
            observaciones="este es un comentario de prueba")

        wf = Workflow(**parametros_iniciales)

        # Actualizamos un proceso no iniciado
        with self.assertRaisesRegexp(
                NameError,
                'Error de operacion. No se puedo actualizar si no se ha iniciado el proceso'
        ):
            wf.actualizar(estado.id)

        wf.iniciar()  # iniciamos el proceso

        # Validamos que no se inicie el proceso nuevamente
        with self.assertRaisesRegexp(
                NameError,
                'Error de operacion. Ya se ha iniciado el proceso para el Pst indicado'
        ):
            wf.iniciar()

        parametros_cambios = Storage(
            pst=self.pst,
            nombre_proceso=self.proceso.nombre,
            observaciones="este es un comentario de prueba numero dos",
            cargar="*")

        wf = Workflow(**parametros_cambios)

        # Comprobamos que se haya actualizado el proceso

        proceso_pst_actualizado = wf.actualizar(estado.id)

        self.assertIsNotNone(proceso_pst_actualizado)

        # Validamos que el estado nuevo sea diferente al anterior
        with self.assertRaisesRegexp(
                NameError,
                'Error de operacion. Ya se encuentra en el estado indicado'):
            wf.actualizar(estado.id)

        # Creamos un nueva instancia de Workflow
        data = Storage(pst=self.pst,
                       nombre_proceso=self.proceso.nombre,
                       cargar="*")
        wf = Workflow(**data)

        # Validamos si se actualizo el proceso
        self.assertEqual(wf.nombre_estado, estado.nombre)

        # obtenemos el estado inicial para el proceso
        estado_inicial = Flujo.objects.get(proceso=self.proceso, inicio=True)

        # Validamos que el flujo secuencia sea el correcto
        self.assertEqual(wf.procesoPst.estado, estado)

        # Validamos que el historial se creo correctamente
        self.assertEqual(len(wf.historial), 2)

        # Validamos que no sea None el historial
        historial = wf.historial[0]
        self.assertIsNotNone(historial)

        # Comprobamos que el historial sea una instancia de HistorialSecuencia
        self.assertIsInstance(historial, HistorialSecuencia)

        # Validamos que el primer registro sea de la secuencia inicial
        self.assertEqual(historial.estado, estado_inicial)

        # Validamos que sean las mismas observaciones
        self.assertEqual(historial.observaciones,
                         parametros_iniciales.observaciones)

        # Comprobamos que el proceso sea el mismo
        self.assertEqual(historial.proceso, self.proceso)

        # Validamos que el proceso sea creado anteriormente
        proceso_pst = ProcesoPst.objects.get(proceso=self.proceso,
                                             activo=True,
                                             pst=self.pst)
        self.assertEqual(historial.proceso_pst, proceso_pst)

        # Validamos que no sea None el historial
        historial = wf.historial[1]
        self.assertIsNotNone(historial)

        # Validamos que el segundo historial sea de la secuencia actualizada
        self.assertEqual(historial.estado, estado)

        # Comprobamos que el proceso sea el mismo
        self.assertEqual(historial.proceso, self.proceso)

        # Comprobamos que el historial sea una instancia de HistorialSecuencia
        self.assertIsInstance(historial, HistorialSecuencia)

        # Validamos si el proceso sea igual al indicado
        self.assertEqual(wf.procesoPst.estado.proceso, self.proceso)
        self.assertEqual(wf.proceso, self.proceso)

        # Verificamos que se hayan guardados las observaciones
        self.assertEqual(historial.observaciones,
                         parametros_cambios.observaciones)

        # Obtenemos un proceso finalizacion
        estado_final = Flujo.objects.get(proceso=self.proceso, fin=True)

        # Creamos una instancia nueva de Workflow
        parametros = Storage(
            pst=self.pst,
            nombre_proceso=self.proceso.nombre,
            observaciones="Finalizamos el proceso con este comentario")

        wf = Workflow(**parametros)

        # Actualizamos el registro al estado final
        wf.actualizar(estado_final.id)

        # Verificamos que el procesoPst sea Falso
        self.assertFalse(wf.procesoPst.activo)

        # Creamos una instancia nueva de Workflow
        parametros = Storage(pst=self.pst,
                             nombre_proceso=self.proceso.nombre,
                             cargar="*")
        wf = Workflow(**parametros)

        # Ya no se puede obtener una instancia del proceso por que esta finalizado
        self.assertIsNone(wf.procesoPst)

        proceso_pst = ProcesoPst.objects.get(pst=self.pst,
                                             proceso=self.proceso)

        self.assertIsNotNone(proceso_pst)
        self.assertEqual(proceso_pst.estado, estado_final)
        self.assertEqual(proceso_pst.nombre_estado, estado_final.nombre)
        self.assertFalse(proceso_pst.activo)
        self.assertIsNotNone(proceso_pst.fecha_fin)
Пример #5
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))