Changeset 66dd87e in observatorio

Timestamp:

Oct 14, 2014, 5:04:52 PM (10 years ago)

Author:

Ing. Roldan Vargas <rvargas@…>

Branches:

master

Children:

1e397ea

Parents:

d9aeac8

Message:

modificación en procesos para la georeferencia de la cadena productiva proveniente de la encuesta industrial y de los datos provenientes del SIGESIC. Se agregaron instrucciones para generar registros de eventos (logs)

File:

• procesos/apps/geocadena/views.py (modified) (5 diffs)

procesos/apps/geocadena/views.py

@@ -39 +39 @@
 from divisionTerritorial import estados
 from models import LayerDivisionEstadal, LayerDivisionMunicipal, LayerDivisionParroquial, LayerRedi, \
-    PoblacionEconomicaActiva, TasaDesempleo, GeoreferenciaIndicador, IndiceNacionalPreciosConsumidor
+    MarcaCadenaProduccion, LayerCentroidePais, GeoreferenciaIndicador, ConexionCadenaProduccion
 
 import logging
@@ -478 +478 @@
             rif = g.node_attr['label'][0:10]
             ue = getUE(rif)
-
-            coordxy = getCoordenadas(ue)
-            if coordxy:
-                nodo.append({'lon': coordxy[0],
-                            'lat': coordxy[1],
-                            'icono': icono,
-                            'uerif': rif,
-                            'uenombre': '',
-                            'uedetalles': 'Ciudad: %s<br>' % '',
-                            'ueproduce': '',
-                            'ueconsume': '',
-                            'ueedo': ue.parroquia.municipio.entidad.nombre,
-                            'uemun': ue.parroquia.municipio.nombre,
-                            'ueparr': ue.parroquia.nombre,
-                            'nivel': ''})
+            if ue:
+                coordxy = getCoordenadas(ue)
+                if coordxy:
+                    nodo.append({'lon': coordxy[0],
+                                'lat': coordxy[1],
+                                'icono': icono,
+                                'uerif': rif,
+                                'uenombre': '',
+                                'uedetalles': 'Ciudad: %s<br>' % '',
+                                'ueproduce': '',
+                                'ueconsume': '',
+                                'ueedo': ue.parroquia.municipio.entidad.nombre,
+                                'uemun': ue.parroquia.municipio.nombre,
+                                'ueparr': ue.parroquia.nombre,
+                                'nivel': ''})
         else:
-            # OBTENER COORDENADAS SEGUN EL CENTROIDE DEL PAI DE ORIGEN
-            pass
+            # Condición que determina las coordenadas geográficas de Unidades Económicas fuera del territorio nacional
+            if g.node_attr['label'].rfind("de origen:") > 0:
+                pais_origen = g.node_attr['label'][g.node_attr['label'].rfind(":") + 1:].strip()
+
+                if LayerCentroidePais.objects.filter(pais__nombre=pais_origen):
+                    centroide_pais = LayerCentroidePais.objects.get(pais__nombre=pais_origen)
+                    nodo.append({
+                        'lon': centroide_pais.lon,
+                        'lat': centroide_pais.lat,
+                        'icono': icono,
+                        'uerif': '',
+                        'uedetalles': 'Pais: %s<br>' % pais_origen,
+                        'ueproduce': '',
+                        'ueconsume': '',
+                        'nivel': ''
+                    })
 
     return nodo
@@ -522 +536 @@
     if grafo:
         user = str(request.user)
-        if grafo == 'encuesta':
+        """
+        if getNodos(user):
             cadena = getNodos(user)
             referencias = getReferencias(user)
-        elif grafo == 'sigesic':
-            cadena = get_nodos_sigesic(user)
+        elif get_nodos_sigesic(user):
+        """
+        cadena = get_nodos_sigesic(user)
         logger.info("Se han generado los datos necesarios para la georeferenciación de la cadena de producción "
                     "consultada")
@@ -572 +588 @@
     if capa and field:
         tabla = get_model('geocadena', capa)
-        logger.info("Petición recibida para mostrar la capa [%s]")
+        logger.info("Petición recibida para mostrar la capa [%s]" % capa)
         qs = tabla.objects.all()
         if cod:
@@ -587 +603 @@
 
     return HttpResponse(content_type='text/plain')
+
+
+#===
+# Vistas para la georeferencia de la cadena de producción
+#===
+class MarcaCadenaProduccionLayer(GeoJSONLayerView):
+    """!
+    Clase que gestiona los datos consultados sobre la cadena de producción
+
+    @author Ing. Roldan D. Vargas G. rvargas@cenditel.gob.ve
+    @author Centro Nacional de Desarrollo e Investigación en Tecnologías Libres (CENDITEL) Nodo Mérida
+    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
+    @date 02-10-2014
+    @version 1.0.1
+    """
+    model = MarcaCadenaProduccion
+    properties = ("grafo_id", "nivel", "sentido", "icono", "rif", "nombre", "produce", "consume")
+
+    def get_queryset(self):
+        """!
+        Método que permite obtener el queryset de la clase para interactuar y gestionar los datos a ser mostrados
+        @author Ing. Roldan D. Vargas G. rvargas@cenditel.gob.ve
+        @author Centro Nacional de Desarrollo e Investigación en Tecnologías Libres (CENDITEL) nodo Mérida
+        @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
+        @date 02-10-2014
+        @param self variable de tipo object con los campos de la clase
+        @return devuelve el queryset que será mostrado por la clase en el mapa
+        """
+        grafo_id = self.request.GET.get('grafo', None)
+
+        if grafo_id:
+            logger.info("Inicio del proceso para la georeferencia de la cadena de producción")
+
+            # Instrucción que elimina datos anteriormente consultados para el grafo
+            self.model.objects.filter(grafo_id=grafo_id).delete()
+            ConexionCadenaProduccion.objects.filter(grafo_id=grafo_id).delete()
+
+            logger.info("Obteniendo datos del grafo consultado [%s]" % grafo_id)
+            try:
+                grafo = AGraph("%s/tmp/%s.dot" % (settings.PATH, grafo_id))
+            except Exception, e:
+                logger.debug("Error al procesar el grafo consultado. Detalles del error: %s" % e)
+
+            if grafo.subgraphs():
+                logger.info("El grafo consultado proviene de la consulta de datos del SIGESIC. Procesando...")
+                tipo_nodo = ''
+
+                # Instrucción que recorre la cadena de producción para obtener los nodos a georeferenciar
+                for g in grafo.subgraphs():
+                    dict_cadena = {
+                        'grafo_id': grafo_id
+                    }
+                    tipo_nodo = g.nodes()[0].attr['color']
+                    # Condiciones que determinan el marcador a mostrar
+                    if tipo_nodo == 'darkgreen':
+                        dict_cadena['icono'] = static('geocadena/imgs/markers/mark_center.png')
+                        dict_cadena['sentido'] = "C"
+                    elif tipo_nodo == 'yellow':
+                        dict_cadena['icono'] = static('geocadena/imgs/markers/mark_up.png')
+                        dict_cadena["sentido"] = "U"
+                    elif tipo_nodo == 'cyan':
+                        dict_cadena['icono'] = static('geocadena/imgs/markers/mark_down.png')
+                        dict_cadena["sentido"] = "D"
+
+                    # Condición que determina los datos de la Unidad Económica a Georeferenciar
+                    if g.node_attr['label'][0] in ["J", "G", "V", "E", "P"]:
+                        rif = g.node_attr['label'][:10]
+                        ue = getUE(rif)
+
+                        if ue:
+                            dict_cadena['rif'] = rif
+                            try:
+                                if ue.nombre is not None and ue.nombre != "NO INDICA":
+                                    dict_cadena['nombre'] = ue.nombre
+                                else:
+                                    dict_cadena['nombre'] = ue.razon_social
+
+                            except AttributeError:
+                                try:
+                                    dict_cadena['nombre'] = ue.nombreestablecimiento
+                                except AttributeError:
+                                    dict_cadena['nombre'] = ue.nombre_comercial
+
+                            coordxy = getCoordenadas(ue)
+                            dict_cadena['geom'] = 'POINT(%s %s)' % (str(coordxy[0]), str(coordxy[1]))
+                        else:
+                            # Si no es posible establecer los datos de la Unidad Económica, se procede a verificar el
+                            # siguiente registro
+                            continue
+                    elif g.node_attr['label'].rfind("origen:") > 0:
+                        pais_origen = g.node_attr['label'][g.node_attr['label'].rfind(":") + 1:].strip()
+                        if LayerCentroidePais.objects.filter(pais__nombre=pais_origen):
+                            centroide_pais = LayerCentroidePais.objects.get(pais__nombre=pais_origen)
+                            dict_cadena['geom'] = centroide_pais.geom
+                            ue_extranjera = g.node_attr['label'].strip("\\n").split("\\n")
+                            dict_cadena['nombre'] = ue_extranjera[0]
+                        else:
+                            # Si no es posible establecer los datos de la Unidad Económica, se procede a verificar el
+                            # siguiente registro
+                            continue
+
+                    # Instrucción que determina la producción de cada Unidad Económica
+                    produce = 'N/E'
+                    if g.nodes():
+                        produce = "<li>%s</li>"
+                        pr = ''
+                        for p in g.nodes():
+                            pr += produce % p.attr['label']
+                        dict_cadena['produce'] = "<ul>%s</ul>" % pr
+
+                    logger.info("Registrando datos en BD del grafo %s" % grafo_id)
+                    self.model.objects.create(**dict_cadena)
+
+                # Instrucción que recorre la cadena de producción para obtener las relaciones entre los nodos a
+                # georeferenciar
+                fcx = lambda z: [
+                    cx.node_attr['label'] for cx in grafo.subgraphs() if str(z) in cx.nodes()
+                    and cx.node_attr['label'] != ''
+                ]
+                for con in grafo.edges():
+                    ue_ini = fcx(con[0])[0]
+                    ue_fin = fcx(con[1])[0]
+                    coord_ini, coord_fin = '', ''
+
+                    # Condición que busca las coordenadas del punto inicial desde el cual realizar la conexión
+                    if ue_ini[0] in ["J", "G", "V", "E", "P"]:
+                        if getUE(ue_ini[:10]):
+                            coord_ini = getCoordenadas(getUE(ue_ini[:10]))
+                    elif ue_ini.rfind("origen:") > 0:
+                        pais_origen = ue_ini[ue_ini.rfind(":") + 1:].strip()
+                        if LayerCentroidePais.objects.filter(pais__nombre=pais_origen):
+                            pais_ini = LayerCentroidePais.objects.get(pais__nombre=pais_origen)
+                            coord_ini = str(pais_ini.geom).strip("POINT (").strip(")").split(" ")
+
+                    # Condición que busca las coordenadas del punto final hasta el cual realizar la conexión
+                    if ue_fin[0] in ["J", "G", "V", "E", "P"]:
+                        if getUE(ue_fin[:10]):
+                            coord_fin = getCoordenadas(getUE(ue_fin[:10]))
+                    elif ue_fin.rfind("origen:") > 0:
+                        pais_origen = ue_fin[ue_fin.rfind(":") + 1:].strip()
+                        if LayerCentroidePais.objects.filter(pais__nombre=pais_origen):
+                            pais_fin = LayerCentroidePais.objects.get(pais__nombre=pais_origen)
+                            coord_fin = str(pais_fin.geom).strip("POINT (").strip(")").split(" ")
+
+                    try:
+                        logger.info(u"Estableciendo conexión entre las Unidades Económicas [%s] y [%s] en las "
+                                    u"coordenadas [%s] y [%s] respectivamente" % (ue_ini, ue_fin, coord_ini, coord_fin))
+                        conexion = "LINESTRING(%s %s, %s %s)" % (
+                            str(coord_ini[0]), str(coord_ini[1]), str(coord_fin[0]), str(coord_fin[1])
+                        )
+                        conex = 'D'
+                        if [i.nodes()[0].attr['color'] for i in grafo.subgraphs() if con[1] in i.nodes()][0] == "cyan":
+                            conex = 'U'
+
+                        ConexionCadenaProduccion.objects.create(
+                            grafo_id=grafo_id, sentido=conex,
+                            geom=conexion, nivel=0
+                        )
+
+                    except Exception, e:
+                        logger.debug(u"No se pudo establecer la relación entre las Unidades Económicas %s y %s. "
+                                     u"Detalles del error: %s" % (ue_ini, ue_fin, e))
+                        continue
+
+            else:
+                logger.info("El grafo consultado proviene de la consulta de datos de la Encuesta Industrial. "
+                            "Procesando...")
+                nodos_atras = lambda x: grafo.in_neighbors(x)
+                if grafo.get_node(0).attr['label'][0] in ["J", "G", "V", "E", "P"]:
+                    logger.info("Obteniendo cadena de producción del nodo [%s]"
+                                % grafo.get_node(0).attr['label'][:10])
+                    nodos = [n for n in grafo.nodes_iter() if n.attr['label'][0] in ["J", "G", "V", "E", "P"]]
+
+                    # Instrucción que obtiene los nodos de Unidades Económicas
+                    for c in nodos:
+                        dict_cadena = {
+                            'grafo_id': grafo_id
+                        }
+
+                        rif = grafo.get_node(c).attr['label'][0:10]
+                        ue = getUE(rif)
+
+                        if ue:
+                            coordxy = getCoordenadas(ue)
+                            dict_cadena['geom'] = 'POINT(%s %s)' % (str(coordxy[0]), str(coordxy[1]))
+                            conex = 'D'
+
+                            if grafo.get_node(c).attr['color'] == 'darkgreen':
+                                logger.info("Estableciendo marca del nodo principal de la Unidad Económica [%s]" % rif)
+                                dict_cadena['icono'] = static('geocadena/imgs/markers/mark_center.png')
+                                dict_cadena['sentido'] = "C"
+                            elif grafo.get_node(c).attr['color'] == 'yellow':
+                                logger.info("Estableciendo marca de nodo aguas arriba para la Unidad Económica [%s]"
+                                            % rif)
+                                dict_cadena['icono'] = static('geocadena/imgs/markers/mark_down.png')
+                                dict_cadena['sentido'] = conex
+                            elif grafo.get_node(c).attr['color'] == 'dodgerblue':
+                                logger.info("Estableciendo marca de nodo aguas abajo para la Unidad Económica [%s]"
+                                            % rif)
+                                dict_cadena['icono'] = static('geocadena/imgs/markers/mark_up.png')
+                                conex = 'U'
+                                dict_cadena['sentido'] = conex
+
+                            if nodos_atras(c):
+                                for x in nodos_atras(c):
+                                    if nodos_atras(x):
+                                        for y in nodos_atras(x):
+                                            ueup = getCoordenadas(getUE(grafo.get_node(y).attr['label'][:10]))
+                                            conexion = "LINESTRING(%s %s, %s %s)" \
+                                                       % (str(coordxy[0]), str(coordxy[1]), str(ueup[0]),
+                                                          str(ueup[1]))
+                                            ConexionCadenaProduccion.objects.create(
+                                                grafo_id=grafo_id, sentido=conex,
+                                                geom=conexion, nivel=0
+                                            )
+                                            logger.info("Estableciendo conexiones de nodos en las coordenadas [%s %s, "
+                                                        "%s %s]" % (str(coordxy[0]), str(coordxy[1]), str(ueup[0]),
+                                                                    str(ueup[1])))
+
+                            try:
+                                if ue.nombre is not None:
+                                    dict_cadena['nombre'] = ue.nombre
+                                else:
+                                    dict_cadena['nombre'] = ue.razon_social
+
+                            except AttributeError, e:
+                                try:
+                                    dict_cadena['nombre'] = ue.nombreestablecimiento
+                                except AttributeError, e:
+                                    try:
+                                        dict_cadena['nombre'] = ue.nombre_comercial
+                                    except AttributeError, e:
+                                        logger.debug("Error al obtener el nombre o razón social de la Unidad Económica "
+                                                     "[%s]. Detalles del error: %s" % (rif, e))
+
+                            try:
+                                dict_cadena['estado'] = ue.parroquia.municipio.entidad.nombre
+                                dict_cadena['municipio'] = ue.parroquia.municipio.nombre
+                                dict_cadena['parroquia'] = ue.parroquia.nombre
+                            except AttributeError, e:
+                                logger.debug("No fue posible obtener información sobre el Estado, Municipio o "
+                                             "Parroquia de la Unidad Económica [%s]. Detalles del error: %s" % (rif, e))
+
+                            # Datos de la producción
+                            produce, consume = '', ''
+                            conn = [g for g in grafo.edges() if c in g]
+                            for cx in conn:
+                                if cx[0] == c and not cx[1].attr['label'][0] in ['J', 'G', 'V', 'E', 'P'] \
+                                    and cx[1].attr['label'].split("\\n")[1] != "":
+                                    produce += "<li>%s</li>" % cx[1].attr['label'].split("\\n")[1]
+                                elif cx[1] == c and not cx[0].attr['label'][0] in ['J', 'G', 'V', 'E', 'P'] \
+                                    and cx[0].attr['label'].split("\\n")[1] != "":
+                                    consume += "<li>%s</li>" % cx[0].attr['label'].split("\\n")[1]
+
+                            if produce != '':
+                                logger.info("Estableciendo datos de la producción de la Unidad Económica [%s]" % rif)
+                                dict_cadena['produce'] = "<ul style='list-style-type: circle;'>%s</ul>" % produce
+                            if consume != '':
+                                logger.info("Estableciendo datos de insumos requeridos para la producción de la Unidad "
+                                            "Económica [%s]" % rif)
+                                dict_cadena['consume'] = "<ul style='list-style-type: circle;'>%s</ul>" % consume
+
+                            logger.info("Registrando datos en BD del grafo %s" % grafo_id)
+                            self.model.objects.create(**dict_cadena)
+                else:
+                    logger.warning("La cadena [%s] a georeferenciar no posee un nodo principal." % grafo_id)
+                    self.model.objects.none()
+
+        else:
+            logger.warning("No se puede georeferenciar la cadena de producción ya que no se ha especificado un grafo")
+            return self.model.objects.none()
+
+        logger.info("Mostrando datos de la Cadena de Producción del grafo [%s]" % grafo_id)
+
+        return self.model.objects.filter(grafo_id=grafo_id)
+
+
+class ConexionCadenaProduccionLayer(GeoJSONLayerView):
+    """!
+    Clase que gestiona los datos consultados sobre las conexiones de los nodos en la cadena de producción
+
+    @author Ing. Roldan D. Vargas G. rvargas@cenditel.gob.ve
+    @author Centro Nacional de Desarrollo e Investigación en Tecnologías Libres (CENDITEL) Nodo Mérida
+    @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
+    @date 13-10-2014
+    @version 1.0.1
+    """
+    model = ConexionCadenaProduccion
+    properties = ("grafo_id", "nivel", "sentido")
+
+    def get_queryset(self):
+        """!
+        Método que permite obtener el queryset de la clase para interactuar y gestionar los datos de las conexiones
+        de los nodos de la cadena de producción a ser mostrados
+        @author Ing. Roldan D. Vargas G. rvargas@cenditel.gob.ve
+        @author Centro Nacional de Desarrollo e Investigación en Tecnologías Libres (CENDITEL) nodo Mérida
+        @copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
+        @date 13-10-2014
+        @param self variable de tipo object con los campos de la clase
+        @return devuelve el queryset que será mostrado por la clase en el mapa
+        """
+        grafo_id = self.request.GET.get('grafo', None)
+
+        if grafo_id:
+            return self.model.objects.filter(grafo_id=grafo_id)
+