def setUp(self):
# acta de Informe fiscal => se supone que cada verificacion ya cuenta con un acta de providencia registrada
objeto_tipo_acta = TipoActa.objects.get(nombre='Informe fiscal')
# cuenta la cantidad de fiscalizaciones y verificaciones registradas
count_verificacion, count_fiscalizacion = Verificacion.objects.count(
), Fiscalizacion.objects.count()
# crea un numero aleatorio de verificacion en caso de existir registros en el modelo
random_id_verificacion = random.randint(
1, count_verificacion) if count_verificacion > 0 else 1
# crea un numero aleatorio de fiscalizacion en caso de existir registros en el modelo
random_id_fiscalizacion = random.randint(
1, count_fiscalizacion) if count_fiscalizacion > 0 else 1
# objeto verificacion que se carga al momento de seleccionar una verificacion de la lista mostrada en el template
objeto_verificacion = Verificacion.objects.get(
pk=random_id_verificacion)
# objeto fiscalizacion que se carga al momento de seleccionar una fiscalizacion de la lista mostrada en el template
objeto_fiscalizacion = Fiscalizacion.objects.get(
pk=random_id_fiscalizacion)
data_verificacion = Storage(
tipo_procedimiento=FactoryCodigoActas.TIPO_VERIFICACION,
objeto_tipo_acta=objeto_tipo_acta,
objeto=objeto_verificacion)
data_fiscalizacion = Storage(
tipo_procedimiento=FactoryCodigoActas.TIPO_FISCALIZACION,
objeto_tipo_acta=objeto_tipo_acta,
objeto=objeto_fiscalizacion)
self.factory_verificacion = FactoryCodigoActas(data_verificacion)
self.factory_fiscalizacion = FactoryCodigoActas(data_fiscalizacion)
def obtener_proceso_pst(self):
"""
Funcion que obtiene el proceso activo para un pst
"""
proceso_pst = []
try:
self.procesoPst = ProcesoPst.objects.get(proceso=self.proceso,
activo=True,
pst=self.pst)
except ProcesoPst.DoesNotExist:
pass
if not self.procesoPst:
search = Storage(nombre__exact=str(self.nombre_proceso),
activo=False)
procesos = Proceso.objects.filter(**search)
if any(procesos):
search = Storage(proceso__in=procesos, activo=True)
proceso_pst = ProcesoPst.objects.filter(**search)
if proceso_pst:
self.procesoPst = proceso_pst[0]
self.proceso = proceso_pst[0].proceso
def get_solicitudes(request, query=None):
cached_pst_list = set(row.relacion_id
for row in models.Cache.objects.all())
parameters = Storage(emprendedor=False, )
if query:
parameters.rif__iexact = query
solicitudes = Pst.objects.filter(
~Q(estatus=models.ESTATUS_REGISTRO_SIN_COMPLETAR),
Q(Q(numero_contribuyente=None) | Q(id__in=cached_pst_list)),
**parameters)
for solicitud in solicitudes:
solicitud.className = solicitud.__class__.__name__
return solicitudes
def get_consecutivo_dentro_providencia(self):
"""
Funcion que cuenta todos los documentos que pertenezcan a ese providencia, pero que no sea providencias y le suma 1
"""
data = Storage()
if self.tipo_procedimiento == self.TIPO_VERIFICACION:
data.verificacion = self.objeto
else:
data.fiscalizacion = self.objeto
consecutivo_dentro_providencia = (
ActaDocumentos.objects.filter(~Q(estatus=ANULADA), **data).exclude(
tipo=self.get_object_acta_tipo_providencia()).count() + 1)
return consecutivo_dentro_providencia
def form_valid(self, form):
"""
Si el formulario es válido, crea el objeto, guarda y
redirigir a la URL proporcionada.
"""
pst = Pst.objects.get(user=self.request.user)
data = helpers.get_files_from_form(form)
data.update(
Storage(
pst=pst,
nombres=form.cleaned_data['nombres'],
apellidos=form.cleaned_data['apellidos'],
cedula=form.cleaned_data['cedula'],
rif=form.cleaned_data['rif'],
cargo_empresa=form.cleaned_data['cargo_empresa'],
telefono_fijo=form.cleaned_data['telefono_fijo'],
telefono_celular=form.cleaned_data['telefono_celular'],
correo_electronico=form.cleaned_data['correo_electronico'],
tipo=CONTACTO
)
)
helpers.save_or_update(RepresentanteContacto, {'pst': pst, 'tipo': CONTACTO}, data)
return super(Paso4View, self).form_valid(form)
def post(self, request, *args, **kwargs):
super(RechazarCertificacionFactibilidadView, self).post(request, *args, **kwargs)
if 'pk' in self.kwargs:
post = request.POST
# obtiene la factibilidad que se esta certificando
factibilidad = model_app_factibilidad.Proyecto.objects.get(id=int(self.kwargs['pk']))
factibilidad.estado = model_app_factibilidad.ANULADO
factibilidad.save()
# obtiene un objeto certificación para crear el log correspondiente
log_certificacion = CertificacionesPST()
log_certificacion.pst = factibilidad.pst
log_certificacion.funcionario = request.user
log_certificacion.tipo = model_app_registro.TIPO_CERTIFICACION_FACTIBILIDAD
observaciones = post['observaciones'] if 'observaciones' in post else ''
log_certificacion.observaciones = observaciones
log_certificacion.save()
data = Storage(
user=factibilidad.user,
tipo_certificacion=u'Factibilidad económica',
estado=u'Rechazada'
)
self.send_email(data)
# se verifica que tipo de figura es para enviar la petición a la plantilla correspondiente
return redirect(self.success_url)
return redirect(self.success_url)
def get_context_data(self, *args, **kwargs):
context = super(Paso5View, self).get_context_data(*args, **kwargs)
filter = Storage(
tipo_actividad=ACTIVIDAD_SECUNDARIA,
pst=Pst.objects.get(user=self.request.user),
cached=True
)
actividades_list = []
act_sec = []
tipos = TipoPst.objects.filter(tipo_persona__in=[PERSONA_JURIDICA, OTRAS])
for t in tipos:
group = "Actividades relacionadas con turismo"
if t.tipo_persona == OTRAS:
group = "Otras"
actividades_list.append({
"id": t.id, "nombre": t.nombre, "group": group,
})
for a in ActividadComercial.objects.filter(**filter):
group = "Actividades relacionadas con turismo"
if a.actividad.tipo_persona == OTRAS:
group = "Otras"
act_sec.append({
"id": a.id,
"nombre": a.actividad.nombre,
"licencia": a.licencia,
"actividad_id": a.actividad.id,
"group": group
})
context['actividad_list'] = json.dumps(actividades_list, ensure_ascii=True)
context['actividades_secundarias'] = json.dumps(act_sec, ensure_ascii=True)
return context
def test_editar_acta(self):
datos_a_editar = {
'codigo_acta': u'INATUR/DE/GRF/FSC/IF140000040001',
'fecha_notificacion_acta': u'07/09/2014',
'observaciones_acta': u'Nuevas observaciones de prueba'
}
#se cargan los datos a editar a la data
self.post_data['codigo_acta'] = datos_a_editar['codigo_acta']
self.post_data['fecha_notificacion_acta'] = datos_a_editar[
'fecha_notificacion_acta']
self.post_data['observaciones_acta'] = datos_a_editar[
'observaciones_acta']
data = Storage(post=self.post_data, is_a_util=False)
fiscalizacion = FiscalizacionObject(data)
#se edita el acta con los datos especificados
fiscalizacion.editar_acta()
#se obtiene el acta editada
acta_editada = ActaDocumentos.objects.get(
codigo=datos_a_editar['codigo_acta'])
#se cargan los datos editados en un diccionario
datos_editados = {
'codigo_acta':
acta_editada.codigo,
'fecha_notificacion_acta':
acta_editada.fecha_notificacion.strftime('%d/%m/%Y'),
'observaciones_acta':
acta_editada.observaciones
}
#se comparan los diccionarios de datos
self.assertDictEqual(datos_a_editar, datos_editados)
def get_context_data(self, **kwargs):
context = super(FactibilidadPasoDos, self).get_context_data()
filter = Storage(pk=self.kwargs['pk'],
user=self.request.user,
estado=ACTIVO)
try:
proyecto = Proyecto.objects.get(**filter)
except Proyecto.DoesNotExist:
raise Http404("Error de registro. La factibilidad no existe")
try:
direccion = DireccionProyecto.objects.get(proyecto=proyecto)
except DireccionProyecto.DoesNotExist:
direccion = None
estados = [{
"id": e.id,
"nombre": e.estado
} for e in Estado.objects.all().order_by('estado')]
servicios = ServicioProyecto.objects.filter(proyecto=proyecto)
servicios = [{"servicio": i.servicio_basico.id} for i in servicios]
context['estados'] = json.dumps(estados,
ensure_ascii=True,
encoding="utf-8")
context['proyecto'] = proyecto
context['direccion'] = direccion
context['servicios'] = json.dumps(servicios,
ensure_ascii=True,
encoding="utf-8")
context['tipografias'] = CARACTERISTICAS_TOPOGRAFICAS
context['vialidades'] = TIPOS_VIALIDADES
context['tipos_servicios'] = ServicioBasico.objects.all()
return context
def form_valid(self, form):
"""
Si el formulario es válido, crea el objeto, guarda y
redirigir a la URL proporcionada.
"""
user = self.request.user
data = helpers.get_files_from_form(form)
data.update(
Storage(
tipo_juridica=form.cleaned_data['tipo_juridica'],
rif=form.cleaned_data['rif'],
razon_social=form.cleaned_data['razon_social'],
pagina_web=form.cleaned_data['pagina_web'],
denominacion_comercial=form.cleaned_data['denominacion_comercial'],
rtn=form.cleaned_data['rtn'],
tipo_figura=form.cleaned_data['tipo_figura'],
estado_contribuyente=form.cleaned_data['estado_contribuyente'],
inicio_actividad_comercial=form.cleaned_data['inicio_actividad_comercial'],
user=user,
)
)
helpers.save_or_update(Pst, {'user': user}, data)
return super(Paso1View, self).form_valid(form)
def iniciar(self):
"""
Inicia el Workflow con el nombre solicitado para un pst y lo guarda
Retorna
- procesoPst (Object): Objeto ProcesoPst
"""
if self.procesoPst:
raise NameError(
'Error de operacion. Ya se ha iniciado el proceso para el Pst indicado'
)
estado = self.obtener_estado(INICIO)
data = Storage(pst=self.pst,
proceso=self.proceso,
estado=estado,
nombre_estado=estado.nombre,
activo=True,
fecha_inicio=datetime.now())
self.procesoPst = ProcesoPst(**data)
self.nombre_estado = estado.nombre
self.procesoPst.save()
self.registrar_historial(estado)
return self.procesoPst
def post(self, request, *args, **kwargs):
super(PstRechazarCertificacionView, self).post(request, *args,
**kwargs)
if 'pk' in self.kwargs:
# obtiene el PST al que se esta certificando
pst = Pst.objects.get(id=int(self.kwargs['pk']))
# se actualiza el estatus a: registro sin completar para que pase al estado de registrar nuevamente sus datos
pst.estatus = models.ESTATUS_REGISTRO_EN_ESPERA
# se guardan los cambios
pst.save(force=True)
# obtiene un objeto certificación para crear el log correspondiente
log_certificacion = models.CertificacionesPST()
log_certificacion.pst = pst
log_certificacion.funcionario = request.user
log_certificacion.tipo = models.TIPO_CERTIFICACION_RECHAZADA
if 'observaciones' in request.POST:
observaciones = request.POST['observaciones']
else:
observaciones = ''
log_certificacion.observaciones = observaciones
log_certificacion.save()
# enviar correo
data = Storage(
user=pst,
tipo_certificacion=u'Prestador de servicios turísticos',
estado=u'Rechazada',
observaciones=observaciones)
self.send_email(data)
# se verifica que tipo de figura es para enviar la petición a la plantilla correspondiente
return redirect(self.success_url)
else:
return redirect(self.success_url)
def crear_acta(self):
if not self.puede_ingresar_acta_tipo_providencia():
return self.redirigir()
# parametros del constructor de acta de documentos
data = Storage(codigo=self.get_codigo_acta(),
tipo=self.get_object_tipo_acta(),
providencia=self.get_object_providencia(),
estatus=self.get_estatus(),
pst=self.get_object_fiscalizacion().pst,
verificacion=None,
fiscalizacion=self.get_object_fiscalizacion(),
fecha_notificacion=self.get_date_with_correct_format(),
observaciones=self.get_observaciones_acta(),
hallazgos_materia=None,
hallazgos_condicion=None,
hallazgos_criterio=None,
hallazgos_efecto=None,
hallazgos_evidencia=None)
acta = ActaDocumentos.create(data)
acta.save()
#se verifica si es un acta cerrada
if self.es_cerrada():
#se obtienen los requisitos de la peticion POST
requisitos = self.get_requisitos()
#se itera sobre los requisitos
for pk in requisitos:
#se crea un storage por cada objeto, cargando sus datos especificos
data_requisito = Storage(
acta=acta,
requisito=Requisito.objects.get(pk=pk),
)
#si el valor NO ES None, entonces fue checkeado el checkbox
if requisitos[pk] != None:
#se setea el valor booleano
data_requisito.entrego = True
else:
#no fue checkeado el checkbox
#se setea el valor booleano
data_requisito.entrego = False
#se instancia el objeto y se crea
req = ActaRequisito.create(data_requisito)
#se guardan los cambios de ese objeto
req.save()
def generar_codigo(self):
"""
Metodo que genera el codigo de la providencia
"""
data_factory = Storage(
tipo_procedimiento=self.tipo,
objeto_tipo_acta=TipoActa.objects.get(nombre=self.tipo_acta)
)
if self.fiscalizacion:
data_factory.objeto = self.fiscalizacion
if self.verificacion:
data_factory.objeto = self.verificacion
factory = FactoryCodigoActas(data_factory)
return factory.make_codigo()
def obtener_estado(self, tipo, id_estado=""):
"""
Funcion que obtiene el estado del proceso que se esta ejecutando para un pst
Retorna
- estado (Object): Flujo
"""
estado = None
if tipo == INICIO:
search = Storage(proceso=self.proceso, inicio=True)
if tipo == ACTUALIZAR and id_estado != "":
search = Storage(pk=id_estado)
estado = Flujo.objects.get(**search)
return estado
def test_get_utils_data(self):
#codigo existente en el base de datos
self.post_utils['codigo_acta'] = u'INATUR/DE/GRF/FSC/IF140000040001'
data = Storage(post=self.post_utils, is_a_util=True)
fiscalizacion = FiscalizacionObject(data)
#se obtienen los datos
context = fiscalizacion.get_utils_data()
self.assertEqual(context['success'], True)
def post(self, request):
"""
Guardamos la modificacion de la Acta para su posterior consulta
Retorna
- Response (Json)= {
"sucess":(boolean), "message": (String)
}
- Ej.
{ "success": True, "message": u"Se ha guardado correctamente la modificacion de la acta" }
"""
pst = Pst.objects.get(user=request.user)
try:
circunscripcion = Circunscripcion.objects.get(
pk=int(request.POST['_circuito_circunscripcion'])
)
registro_mercantil = RegistroMercantil.objects.get(
pk=int(request.POST['_registro_mercantil'])
)
fecha_registro = request.POST['_fecha_registro']
registro = datetime.strptime(fecha_registro, '%d/%m/%Y').date()
fecha_asamblea = request.POST['_fecha_ultima_asamblea']
ultima_asamblea = datetime.strptime(fecha_asamblea, '%d/%m/%Y').date()
except Exception as e:
raise Http404("Parametros malformados %s" % e.message)
if len(Acta.objects.filter(pst=pst, tipo_acta=ORIGINAL, cached=True)) == 1:
try:
data = Storage(
pst = pst,
circuito_circunscripcion=circunscripcion,
registro_mercantil=registro_mercantil,
fecha_registro=registro,
fecha_ultima_asamblea=ultima_asamblea,
tomo=request.POST['_tomo'],
numero_tomo=request.POST['_numero_tomo'],
archivo_acta_constitutiva=request.FILES.get('_archivo_acta_constitutiva'),
objetivo_modificacion=request.POST['_objetivo_modificacion'],
motivo_modificacion=request.POST['_motivo_modificacion'],
tipo_acta=MODIFICACION
)
acta = Acta.create(data)
acta.save(force_cached=True)
response = dict(
success=True,
message=u"Se ha guardado correctamente la modificacion de la acta")
except Exception as e:
raise Http404("Parametros malformados %s" % e.message)
else:
response = dict(
success=False,
message=u"Debe registrar una acta original, para realizar modificaciones"
)
response = json.dumps(response, ensure_ascii=True)
return HttpResponse(response, content_type='application/json')
def test_A_crear_providencia_verificacion(self):
"""
¿Se genera la providencia correctamente?
"""
for verificacion in self.verificacion:
data = Storage(pst=self.pst, verificacion=verificacion)
providencia = Providencia(**data)
p = providencia.crear()
self.assertIsInstance(p, ActaDocumentos)
def test_B_crear_providencia_fiscalizacion(self):
"""
¿Se genera la providencia correctamente?
"""
for fiscalizacion in self.fiscalizacion:
data = Storage(pst=self.pst, fiscalizacion=fiscalizacion)
providencia = Providencia(**data)
p = providencia.crear()
self.assertIsInstance(p, ActaDocumentos)
def get_object_providencia(self):
"""
Funcion que retorna el objeto providencia de la verificacion pasada como parametro
y que no tenga estatus anulada
"""
data = Storage(tipo=self.get_object_acta_tipo_providencia(), )
if self.tipo_procedimiento == self.TIPO_VERIFICACION:
data.verificacion = self.objeto
else:
data.fiscalizacion = self.objeto
try:
objeto_providencia = ActaDocumentos.objects.get(
~Q(estatus=ANULADA), **data)
except ObjectDoesNotExist:
# solo tiene providencia ANULADA o no tiene, puede ingresar otra providencia
objeto_providencia = None
return objeto_providencia
def test_get_utils_codigo(self):
data = Storage(
post=self.post_utils,
is_a_util=True
)
verificacion = VerificacionObject(data)
#se obtiene el codigo
context = verificacion.get_utils_codigo()
self.assertEqual(context['success'], True)
def test_crear_acta(self):
data = Storage(post=self.post_data, is_a_util=False)
fiscalizacion = FiscalizacionObject(data)
fiscalizacion.crear_acta()
#se obtiene la ultima acta registrada
ultima_verificacion_registrada = ActaDocumentos.objects.last()
#se comparan los codigos para ver si son iguales
self.assertEqual(fiscalizacion.get_codigo_acta(),
ultima_verificacion_registrada.codigo)
def post(self, request, **kwargs):
"""
Metodo que guarda la modificacion de la solicitud
Method: POST
"""
usuario = None
correo = "*****@*****.**" % (request.POST['nombres'],request.POST['apellidos'])
correo2 = "*****@*****.**" % (request.POST['nombres'],request.POST['apellidos'])
cedula = request.POST['cedula'][2:]
rif = "J-%s-0" % cedula
data = Storage(
nombres = request.POST['nombres'],
apellidos = request.POST['apellidos'],
rif = rif,
cedula = request.POST['cedula'],
correo_electronico = correo,
correo_electronico2 = correo2,
is_active = False,
role = ROLE_FUNCIONARIO_APOYO
)
try:
usuario = User(**data)
usuario.save()
data = Storage(
tipo_apoyo = request.POST['tipo_apoyo'], funcionario = usuario
)
tipo = FuncionarioTipoApoyo(**data)
tipo.save()
except IntegrityError:
response = dict(success=False, message="Funcionario ya se encuentra registrado")
if usuario.id:
serializer = UserSerializer(usuario)
response = dict(
success = True,
message = "El funcionario de apoyo se agregó correctamente",
data = serializer.data
)
response = json.dumps(response, ensure_ascii=True)
return HttpResponse(response, content_type='application/json')
def get_context_data(self, **kwargs):
context = super(FactibilidadPasoTres, self).get_context_data()
filter = Storage(pk=self.kwargs['pk'],
user=self.request.user,
estado=ACTIVO)
try:
proyecto = Proyecto.objects.get(**filter)
except Proyecto.DoesNotExist:
raise Http404("Error de registro. La factibilidad no existe")
context['proyecto'] = proyecto
context['range'] = range(1, 6)
return context
def form_valid(self, form):
"""
Si el formulario es válido, crea el objeto, guarda y redirigir a la URL proporcionada.
"""
data = helpers.get_files_from_form(form)
proyecto = Proyecto.objects.get(pk=self.kwargs['pk'],
user=self.request.user,
estado=ACTIVO)
data.update(Storage(proyecto=proyecto))
helpers.save_or_update(SocioTecnicoProyecto, {'proyecto': proyecto},
data)
return super(FactibilidadPasoCuatro, self).form_valid(form)
def form_valid(self, form):
"""
Si el formulario es válido, crea el objeto, guarda y
redirigir a la URL proporcionada.
"""
pst = Pst.objects.get(user=self.request.user)
data = Storage(
actividad=form.cleaned_data['actividad'],
licencia=form.cleaned_data['actividad_principal_licencia']
)
helpers.save_or_update(ActividadComercial,
{'pst': pst, "tipo_actividad":ACTIVIDAD_PRINCIPAL}, data
)
return super(Paso5View, self).form_valid(form)
def iniciar_datos(self):
"""
Metodo que inicia el storage
"""
if self.verificacion:
self.tipo = FactoryCodigoActas.TIPO_VERIFICACION
if self.fiscalizacion:
self.tipo = FactoryCodigoActas.TIPO_FISCALIZACION
self.data = Storage(
pst=self.pst, verificacion=self.verificacion,
fiscalizacion=self.fiscalizacion, providencia=None,
tipo=TipoActa.objects.get(nombre=self.tipo_acta),
estatus=NO_NOTIFICADA,
)
def registrar_historial(self, estado):
"""
Funcion que guarda el historial de los pasos realizados para cada proceso
Parametros
- Estado (Object): Objeto estado para generar el historial
"""
user = User.objects.get(pk=1) # Usuario defecto
if self.request.user:
user = self.request.user
data = Storage(user=user,
proceso_pst=self.procesoPst,
estado=estado,
observaciones=self.observaciones,
proceso=self.proceso)
historial = HistorialSecuencia(**data)
historial.save()
def form_valid(self, form):
"""
Si el formulario es válido, crea el objeto, guarda
y redirige a la URL proporcionada.
"""
pst = Pst.objects.get(user=self.request.user)
data = helpers.get_files_from_form(form)
data.update(
Storage(
pst=pst,
numero=form.cleaned_data['numero'],
fecha=form.cleaned_data['fecha']
)
)
helpers.save_or_update(Sunacoop, {'pst': pst}, data)
return super(Paso8View, self).form_valid(form)
def post(self, request, *args, **kwargs):
"""
Guardamos los accionistas para su posterior consulta
Retorna
- Response (Json)=
{ "sucess":(boolean), "message": (String) }
- Ej.
{ "success": True,
"message": u"Se ha guardado correctamente el Accionista" }
"""
response = dict(success=False, message=u"No logro registrar el Accionista")
try:
fecha_incorporacion = request.POST['fecha_incorporacion']
incorporacion = datetime.strptime(fecha_incorporacion, '%d/%m/%Y').date()
except ValueError as e:
raise Http404("Parametros malformados %s" % e.message)
data = Storage(
pst=Pst.objects.get(user=request.user),
nombres=request.POST['nombre'],
apellidos=request.POST['apellido'],
cedula=request.POST['cedula'],
rif=request.POST['rif'],
director=False,
numero_acciones=request.POST['numero_acciones'],
fecha_incorporacion=incorporacion,
archivo_cedula=request.FILES.get('archivo_cedula'),
archivo_rif=request.FILES.get('archivo_rif'),
)
if 'director' in request.POST:
data['director'] = True
accionista = Accionista.create(data)
accionista.save(force_cached=True)
if accionista.id is not None:
response = dict(success=True,
message=u"Se ha guardado correctamente el Accionista")
response = json.dumps(response, ensure_ascii=True)
return HttpResponse(response, content_type='application/json')