Пример #1
0
    def save_tab_analysis(self):
        """ Save tab from tab 'Analysis' """

        # super(NodeDialog, self).save_tab_analysis()
        if self.epa_type == "JUNCTION":
            values = []
            sql = "UPDATE " + self.schema_name + "." + self.epa_table + " SET "
            for i in range(len(self.fields_junction)):
                widget_name = self.epa_table + "_" + self.fields_junction[i]
                value = utils_giswater.getWidgetText(widget_name, True)
                values.append(value)
                sql += self.fields_junction[i] + " = " + str(values[i]) + ", "
            sql = sql[:-2]
            sql += " WHERE node_id = '" + self.id + "'"
            self.dao.execute_sql(sql)

        if self.epa_type == "TANK":
            values = []
            sql = "UPDATE " + self.schema_name + "." + self.epa_table + " SET "
            for i in range(len(self.fields_tank)):
                widget_name = self.epa_table + "_" + self.fields_tank[i]
                value = utils_giswater.getWidgetText(widget_name, True)
                values.append(value)
                sql += self.fields_tank[i] + " = " + str(values[i]) + ", "
            sql = sql[:-2]
            sql += " WHERE node_id = '" + self.id + "'"
            self.dao.execute_sql(sql)
Пример #2
0
 def init_config_arc(self):
     ''' Custom form initial configuration for 'Arc' '''
     
     # Define class variables
     self.field_id = "arc_id"
     self.id = utils_giswater.getWidgetText(self.field_id, False)
     self.epa_type = utils_giswater.getWidgetText("epa_type", False)    
     if self.epa_type == 'PIPE':
         self.epa_table = 'inp_pipe'
     
     # Get widget controls
     self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis")            
     self.tab_event = self.dialog.findChild(QTabWidget, "tab_event")   
     self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")                   
          
     # Manage tab visibility
     self.set_tabs_visibility()
     
     # Manage i18n
     self.translate_form('ws_arc')        
     
     # Fill combo 'arc type' from 'epa_type'
     self.fill_arc_type()
     
     # Load data from related tables
     self.load_data()
     
     # Set layer in editing mode
     self.layer.startEditing()
Пример #3
0
   def set_filter_table(self, widget):
       ''' Get values selected by the user and sets a new filter for its table model '''
       
       # Get selected dates
       date_from = self.date_document_from.date().toString('yyyyMMdd') 
       date_to = self.date_document_to.date().toString('yyyyMMdd') 
       if (date_from > date_to):
           message = "Selected date interval is not valid"
           self.controller.show_warning(message, context_name='ui_message')                   
           return
       
       # Set filter
       expr = self.field_id+" = '"+self.id+"'"
       expr+= " AND date >= '"+date_from+"' AND date <= '"+date_to+"'"
       
       # Get selected values in Comboboxes        
       doc_type_value = utils_giswater.getWidgetText("doc_type")
       if doc_type_value != 'null': 
           expr+= " AND doc_type = '"+doc_type_value+"'"
       doc_tag_value = utils_giswater.getWidgetText("doc_tag")
       if doc_tag_value != 'null': 
           expr+= " AND tagcat_id = '"+doc_tag_value+"'"
       doc_user_value = utils_giswater.getWidgetText("doc_user")
       if doc_user_value != 'null':
           expr+= " AND user_name = '"+doc_user_value+"'"
 
       # Refresh model with selected filter
       widget.model().setFilter(expr)
       widget.model().select()   
Пример #4
0
    def mg_table_wizard_import_csv(self):

        # Get selected table, delimiter, and header
        alias = utils_giswater.getWidgetText(self.dlg.cbo_table)  
        table_name = self.table_dict[alias]
        delimiter = utils_giswater.getWidgetText(self.dlg.cbo_delimiter)  
        header_status = self.dlg.chk_header.checkState()             
        
        # Get CSV file. Check if file exists
        self.file_path = self.dlg.txt_file_path.toPlainText()
        if not os.path.exists(self.file_path):
            message = "Selected file not found: "+self.file_path
            self.controller.show_warning(message, context_name='ui_message' )
            return False      
              
        # Open CSV file for read and copy into database
        rf = open(self.file_path)
        sql = "COPY "+self.schema_name+"."+table_name+" FROM STDIN WITH CSV"
        if (header_status == Qt.Checked):
            sql+= " HEADER"
        sql+= " DELIMITER AS '"+delimiter+"'"
        status = self.dao.copy_expert(sql, rf)
        if status:
            self.dao.rollback()
            msg = "Cannot import CSV into table "+table_name+". Reason:\n"+str(status).decode('utf-8')
            QMessageBox.warning(None, "Import CSV", self.controller.tr(msg))
            return False
        else:
            self.dao.commit()
            message = "Selected CSV has been imported successfully"
            self.controller.show_info(message, context_name='ui_message' )
Пример #5
0
 def init_config_node(self):
     ''' Custom form initial configuration for 'Node' '''
     
     # Define class variables
     self.field_id = "node_id"        
     self.id = utils_giswater.getWidgetText(self.field_id, False)  
     self.node_type = utils_giswater.getWidgetText("node_type", False)        
     self.nodecat_id = utils_giswater.getWidgetText("nodecat_id", False)        
     self.epa_type = utils_giswater.getWidgetText("epa_type", False)      
     
     # Get widget controls
     self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis")            
     self.tab_event = self.dialog.findChild(QTabWidget, "tab_event")         
     self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")            
          
     # Manage tab visibility
     self.set_tabs_visibility()
     
     # Manage i18n
     self.translate_form('ws_node')        
     
     # Define and execute query to populate combo 'node_type_dummy'
     self.fill_node_type_id()
     
     # Load data from related tables
     self.load_data()
     
     # Set layer in editing mode
     self.layer.startEditing()
Пример #6
0
    def init_config_form(self):
        ''' Custom form initial configuration '''
        
        # Define local variables
        context_name = "ws_arc"            
        table_element = "v_ui_element_x_arc"           
        table_document = "v_ui_doc_x_arc"
        
        # Define class variables
        self.field_id = "arc_id" 
        self.id = utils_giswater.getWidgetText(self.field_id, False)  
        self.filter = self.field_id+" = '"+str(self.id)+"'"                    
        self.arc_type = utils_giswater.getWidgetText("cat_arctype_id", False)        
        self.arccat_id = utils_giswater.getWidgetText("arccat_id", False)        
        self.epa_type = utils_giswater.getWidgetText("epa_type", False) 
        self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis")            
        self.tab_event = self.dialog.findChild(QTabWidget, "tab_event")  
        self.tab_event_2 = self.dialog.findChild(QTabWidget, "tab_event_2")        
        self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")      
        self.tbl_info = self.dialog.findChild(QTableView, "tbl_info")    
        self.tbl_document = self.dialog.findChild(QTableView, "tbl_document") 
        self.tbl_rtc = self.dialog.findChild(QTableView, "tbl_rtc")             
             
        # Manage tab visibility
        self.set_tabs_visibility()
        
        # Manage i18n
        self.translate_form(context_name)        
        
        # Define and execute query to populate combo 'cat_arctype_id_dummy'
        self.fill_arc_type_id()        
      
        # Load data from related tables
        self.load_data()
        
        # Set layer in editing mode
        self.layer.startEditing()
        
        # Fill the info table
        self.fill_table(self.tbl_info, self.schema_name+"."+table_element, self.filter)
        
        # Configuration of  info table
        self.set_configuration(self.tbl_info, table_element)
        
        # Fill the tab Document
        self.fill_tbl_document(self.tbl_document, self.schema_name+"."+table_document, self.filter)
        
        # Configuration of table document
        self.set_configuration(self.tbl_document, table_document)

        # Set signals    
        btn_element_delete = self.dialog.findChild(QPushButton, "btn_element_delete")
        btn_doc_delete = self.dialog.findChild(QPushButton, "btn_doc_delete")
        if btn_element_delete:             
            btn_element_delete.clicked.connect(partial(self.delete_records, self.tbl_info, table_element))  
        if btn_doc_delete:               
            btn_doc_delete.clicked.connect(partial(self.delete_records, self.tbl_document, table_document))   
 def fill_geomcat_id(self):
     
     catalog_id = utils_giswater.getWidgetText(self.dlg_cat.id)
     self.close_dialog(self.dlg_cat)
     utils_giswater.setDialog(self.dlg)
     utils_giswater.setWidgetEnabled(self.dlg.node_nodecat_id, True)
     utils_giswater.setWidgetText(self.dlg.node_nodecat_id, catalog_id)        
Пример #8
0
 def generic_zoom(self, fieldname, combo, field_index=0):  
     """ Get selected element from the combo, and returns a feature request expression """
     
     # Get selected element from combo
     element = utils_giswater.getWidgetText(combo)                    
     if element == 'null':
         return None
             
     elem = combo.itemData(combo.currentIndex())
     if not elem:
         # that means that user has edited manually the combo but the element
         # does not correspond to any combo element
         message = 'Element {} does not exist'.format(element)
         self.controller.show_warning(message) 
         return None
     
     # Check if the expression is valid
     aux = fieldname + " = '" + str(elem[field_index]) + "'"
     expr = QgsExpression(aux)    
     if expr.hasParserError():   
         message = expr.parserErrorString() + ": " + aux
         self.controller.show_warning(message)        
         return     
     
     return expr
    def fill_filter2(self, wsoftware, geom_type):

        # Get values from filters
        mats = utils_giswater.getWidgetText(self.dlg_cat.matcat_id)

        # Set SQL query
        sql_where = ""
        sql = ("SELECT DISTINCT(" + self.field2 + ")"
               " FROM " + self.schema_name + ".cat_" + geom_type)

        # Build SQL filter
        if mats != "null":
            if sql_where == "":
                sql_where = " WHERE"
            sql_where += " matcat_id = '" + mats + "'"
        if wsoftware == 'ws' and self.node_type_text is not None:
            if sql_where == "":
                sql_where = " WHERE"
            else:
                sql_where += " AND"
            sql_where += " " + geom_type + "type_id = '" + self.node_type_text + "'"
        sql += sql_where + " ORDER BY " + self.field2

        rows = self.controller.get_rows(sql)
        utils_giswater.fillComboBox(self.dlg_cat.filter2, rows)
        self.fill_filter3(wsoftware, geom_type)
    def delete_feature_at_plan_psector(self, geom_type, list_id, plan_om):
        """ Delete features_id to table plan_@geom_type_x_psector"""

        value = utils_giswater.getWidgetText(self.dlg.psector_id)
        sql = ("DELETE FROM " + self.schema_name + "." + plan_om + "_psector_x_" + geom_type + ""
               " WHERE " + geom_type + "_id IN (" + list_id + ") AND psector_id = '" + str(value) + "'")
        self.controller.execute_sql(sql)
    def generate_csv(self, path, viewname, previous_dialog):

        # Get columns name in order of the table
        sql = ("SELECT column_name FROM information_schema.columns"
               " WHERE table_name = '" + "v_" + self.plan_om + "_psector'"
               " AND table_schema = '" + self.schema_name.replace('"', '') + "'"
               " ORDER BY ordinal_position")

        rows = self.controller.get_rows(sql)
        columns = []
        for i in range(0, len(rows)):
            column_name = rows[i]
            columns.append(str(column_name[0]))

        sql = ("SELECT * FROM " + self.schema_name + "." + viewname + ""
               " WHERE psector_id = '" + str(utils_giswater.getWidgetText(previous_dialog.psector_id)) + "'")
        rows = self.controller.get_rows(sql)
        all_rows = []
        all_rows.append(columns)
        for i in rows:
            all_rows.append(i)

        with open(path, "w") as output:
            writer = csv.writer(output, lineterminator='\n')
            writer.writerows(all_rows)
    def open_node_form(self, idx):
        """ Open form corresponding to start or end node of the current arc """

        field_node = "node_" + str(idx)
        widget = self.dialog.findChild(QLineEdit, field_node)
        node_id = utils_giswater.getWidgetText(self.dialog, widget)
        if not widget:
            self.controller.log_info("widget not found", parameter=field_node)
            return

        # get pointer of node by ID
        aux = "\"node_id\" = "
        aux += "'" + str(node_id) + "'"
        expr = QgsExpression(aux)
        if expr.hasParserError():
            message = "Expression Error"
            self.controller.show_warning(message,
                                         parameter=expr.parserErrorString())
            return

        # List of nodes from node_type_cat_type - nodes which we are using
        for feature_cat in self.feature_cat.itervalues():
            if feature_cat.type == 'NODE':
                layer = self.controller.get_layer_by_layername(
                    feature_cat.layername)
                if layer:
                    # Get a featureIterator from this expression:
                    it = layer.getFeatures(QgsFeatureRequest(expr))
                    id_list = [i for i in it]
                    if id_list:
                        self.iface.openFeatureForm(layer, id_list[0])
Пример #13
0
    def open_web_browser(self, widget):
        """ Display url using the default browser """

        url = utils_giswater.getWidgetText(widget)
        if url == 'null':
            url = 'www.giswater.org'
        webbrowser.open(url)
Пример #14
0
    def exist_object(self, table_object):
        """ Check if selected object (document or element) already exists """

        # Reset list of selected records
        self.reset_lists()

        field_object_id = "id"
        if table_object == "element":
            field_object_id = table_object + "_id"
        object_id = utils_giswater.getWidgetText(table_object + "_id")

        # Check if we already have data with selected object_id
        sql = ("SELECT * "
               " FROM " + self.schema_name + "." + str(table_object) + ""
               " WHERE " + str(field_object_id) + " = '" + str(object_id) +
               "'")
        row = self.controller.get_row(sql, log_info=False)

        # If object_id not found: Clear data
        if not row:
            self.reset_widgets(table_object)
            if hasattr(self, 'single_tool_mode'):
                # some tools can work differently if standalone or integrated in
                # another tool
                if self.single_tool_mode:
                    self.remove_selection(True)
            else:
                self.remove_selection(True)
            self.reset_model(table_object, "arc")
            self.reset_model(table_object, "node")
            self.reset_model(table_object, "connec")
            self.reset_model(table_object, "element")
            if self.project_type == 'ud':
                self.reset_model(table_object, "gully")
            if table_object != 'doc':
                self.dlg.enddate.setEnabled(False)
            return

        if table_object != 'doc':
            self.dlg.enddate.setEnabled(True)

        # Fill input widgets with data of the @row
        self.fill_widgets(table_object, row)

        # Check related 'arcs'
        self.get_records_geom_type(table_object, "arc")

        # Check related 'nodes'
        self.get_records_geom_type(table_object, "node")

        # Check related 'connecs'
        self.get_records_geom_type(table_object, "connec")

        # Check related 'elements'
        self.get_records_geom_type(table_object, "element")

        # Check related 'gullys'
        if self.project_type == 'ud':
            self.get_records_geom_type(table_object, "gully")
Пример #15
0
    def exist_object(self, dialog, table_object):
        """ Check if selected object (document or element) already exists """
        
        # Reset list of selected records
        self.reset_lists()
        
        field_object_id = "id"
        if table_object == "element":
            field_object_id = table_object + "_id"           
        object_id = utils_giswater.getWidgetText(dialog, table_object + "_id")

        # Check if we already have data with selected object_id
        sql = ("SELECT * " 
               " FROM " + self.schema_name + "." + str(table_object) + ""
               " WHERE " + str(field_object_id) + " = '" + str(object_id) + "'")
        row = self.controller.get_row(sql, log_info=False)

        # If object_id not found: Clear data
        if not row:    
            self.reset_widgets(dialog, table_object)
            if table_object == 'element':
                self.set_combo(dialog, 'state', 'value_state', 'state_vdefault', field_name='name')
                self.set_combo(dialog, 'expl_id', 'exploitation', 'exploitation_vdefault', field_id='expl_id',field_name='name')
                self.set_calendars(dialog, 'builtdate', 'config_param_user', 'value', 'builtdate_vdefault')
                self.set_combo(dialog, 'workcat_id', 'cat_work', 'workcat_vdefault', field_id='id', field_name='id')
            if hasattr(self, 'single_tool_mode'):
                # some tools can work differently if standalone or integrated in
                # another tool
                if self.single_tool_mode:
                    self.remove_selection(True)
            else:
                self.remove_selection(True)
            self.reset_model(dialog, table_object, "arc")
            self.reset_model(dialog, table_object, "node")
            self.reset_model(dialog, table_object, "connec")
            self.reset_model(dialog, table_object, "element")
            if self.project_type == 'ud':
                self.reset_model(dialog, table_object, "gully")
            return


        # Fill input widgets with data of the @row
        self.fill_widgets(dialog, table_object, row)

        # Check related 'arcs'
        self.get_records_geom_type(dialog, table_object, "arc")
        
        # Check related 'nodes'
        self.get_records_geom_type(dialog, table_object, "node")
        
        # Check related 'connecs'
        self.get_records_geom_type(dialog, table_object, "connec")

        # Check related 'elements'
        self.get_records_geom_type(dialog, table_object, "element")

        # Check related 'gullys'
        if self.project_type == 'ud':        
            self.get_records_geom_type(dialog, table_object, "gully")
Пример #16
0
    def save_tab_add_info(self):
        """ Save tab from tab 'Add. info' """

        if self.epa_type == "TANK":
            vmax = utils_giswater.getWidgetText("man_tank_vmax", False)
            area = utils_giswater.getWidgetText("man_tank_area", False)
            sql = " UPDATE " + self.schema_name + ".man_tank SET"
            sql += " vmax = " + str(vmax) + ", area = " + str(area)
            sql += " WHERE node_id = '" + self.id + "';"
            self.dao.execute_sql(sql)
            total = self.dao.get_rowcount()
            # Perform an INSERT if any record has been updated
            # TODO: If trigger was working correctly this wouldn't be necessary!
            if total == 0:
                sql = "INSERT INTO " + self.schema_name + ".man_tank (node_id, vmax, area) VALUES"
                sql += " ('" + self.id + "', " + str(vmax) + ", " + str(area) + ");"
                self.dao.execute_sql(sql)
Пример #17
0
 def filter_elementcat_id(self):
     """ Filter QComboBox @elementcat_id according QComboBox @elementtype_id """
     
     sql = ("SELECT DISTINCT(id) FROM " + self.schema_name + ".cat_element"
            " WHERE elementtype_id = '" + utils_giswater.getWidgetText(self.dlg_add_element, "element_type") + "'"
            " ORDER BY id")
     rows = self.controller.get_rows(sql)
     utils_giswater.fillComboBox(self.dlg_add_element, "elementcat_id", rows, False)
Пример #18
0
 def fill_arc_type(self):
     ''' Define and execute query to populate combo 'cat_arctype_id' '''
     cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", False)
     sql = "SELECT id, man_table, epa_table FROM " + self.schema_name + ".arc_type"
     sql += " WHERE epa_default = '" + self.epa_type + "' ORDER BY id"
     rows = self.dao.get_rows(sql)
     utils_giswater.fillComboBox("cat_arctype_id", rows)
     utils_giswater.setWidgetText("cat_arctype_id", cat_arctype_id)
Пример #19
0
 def fill_arc_type(self):
     ''' Define and execute query to populate combo 'cat_arctype_id' '''
     cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", False)     
     sql = "SELECT id, man_table, epa_table FROM "+self.schema_name+".arc_type"
     sql+= " WHERE epa_default = '"+self.epa_type+"' ORDER BY id"
     rows = self.dao.get_rows(sql)       
     utils_giswater.fillComboBox("cat_arctype_id", rows)
     utils_giswater.setWidgetText("cat_arctype_id", cat_arctype_id)
Пример #20
0
 def save_tab_add_info(self):
     ''' Save tab from tab 'Add. info' '''   
               
     if self.epa_type == 'TANK':
         vmax = utils_giswater.getWidgetText("man_tank_vmax", False)
         area = utils_giswater.getWidgetText("man_tank_area", False)
         sql= " UPDATE "+self.schema_name+".man_tank SET" 
         sql+= " vmax = "+str(vmax)+ ", area = "+str(area)
         sql+= " WHERE node_id = '"+self.id+"';"
         self.dao.execute_sql(sql)
         total = self.dao.get_rowcount()
         # Perform an INSERT if any record has been updated
         # TODO: If trigger was working correctly this wouldn't be necessary!
         if total == 0:
             sql = "INSERT INTO "+self.schema_name+".man_tank (node_id, vmax, area) VALUES"
             sql+= " ('"+self.id+"', "+str(vmax)+ ", "+str(area)+");"     
             self.dao.execute_sql(sql)
Пример #21
0
def init_config():
     
    feature_dialog.dialog.findChild(QComboBox, "connecat_id").setVisible(False)         
    connecat_id = utils_giswater.getWidgetText("connecat_id", False)
    
    # TODO: Define slots
    
    feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save)            
    feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)        
Пример #22
0
 def change_arc_type(self):
     ''' Define and execute query to populate combo 'arccat_id_dummy' '''
     cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", True)
     sql = "SELECT id FROM " + self.schema_name + ".cat_arc"
     sql += " WHERE arctype_id = " + cat_arctype_id + " ORDER BY id"
     rows = self.dao.get_rows(sql)
     utils_giswater.fillComboBox("arccat_id_dummy", rows, False)
     # Select first item by default
     self.change_arc_cat()
Пример #23
0
 def change_arc_type(self):
     ''' Define and execute query to populate combo 'arccat_id_dummy' '''
     cat_arctype_id = utils_giswater.getWidgetText("cat_arctype_id", True)    
     sql = "SELECT id FROM "+self.schema_name+".cat_arc"
     sql+= " WHERE arctype_id = "+cat_arctype_id+" ORDER BY id"   
     rows = self.dao.get_rows(sql)
     utils_giswater.fillComboBox("arccat_id_dummy", rows, False) 
     # Select first item by default         
     self.change_arc_cat()       
Пример #24
0
    def compare_depth(self, widget_ymax, show_message):
        widget_ymax.setStyleSheet("border: 1px solid gray")
        node_id = utils_giswater.getWidgetText(self.dialog, 'node_id')
        ymax = utils_giswater.getWidgetText(self.dialog, widget_ymax)
        if ymax is None:
            return
        bad_alert = False
        sql = ("SELECT * from " + self.schema_name +
               ".v_ui_node_x_connection_upstream "
               " WHERE node_id = '" + str(node_id) + "'")
        rows = self.controller.get_rows(sql, log_sql=False)
        arcs_list = ""
        if len(rows) > 0:
            arcs_list += "Upstream: "
            for row in rows:
                if row['upstream_depth'] is not None:
                    if float(ymax) < float(row['upstream_depth']):
                        widget_ymax.setStyleSheet("border: 1px solid red")
                        arcs_list += str((row['feature_id'] + ", "))
                        bad_alert = True
        sql = ("SELECT * from " + self.schema_name +
               ".v_ui_node_x_connection_downstream "
               " WHERE node_id = '" + str(node_id) + "'")
        rows = self.controller.get_rows(sql, log_sql=False)
        if len(rows) > 0:
            arcs_list += "Downstream: "
            for row in rows:
                if row['downstream_depth'] is not None:
                    if float(ymax) < float(row['downstream_depth']):
                        widget_ymax.setStyleSheet("border: 1px solid red")
                        arcs_list += str((row['feature_id'] + ", "))
                        bad_alert = True
        if len(arcs_list) > 2:
            arcs_list = arcs_list[:-2]

        if show_message and bad_alert:
            msg = "The depth of this node is less than the arc/'s {}".format(
                arcs_list)
            # self.controller.show_info_box(text=msg, title="Info")
            msg_box = QMessageBox()
            msg_box.setIcon(3)
            msg_box.setWindowTitle("Warning")
            msg_box.setText(msg)
            msg_box.exec_()
    def filter_by_id(self, table, widget_txt, tablename):

        id_ = utils_giswater.getWidgetText(self.dlg_min_edit, widget_txt)
        if id_ != 'null':
            expr = " id = '" + id_ + "'"
            # Refresh model with selected filter
            table.model().setFilter(expr)
            table.model().select()
        else:
            self.fill_table_mincut_management(self.tbl_mincut_edit, self.schema_name + "." + tablename)
 def filter_by_state(self, table, widget, tablename):
     
     state = utils_giswater.getWidgetText(self.dlg_min_edit, widget)
     if state != 'null':
         expr_filter = " state = '" + str(state) + "'"
         # Refresh model with selected expr_filter
         table.model().setFilter(expr_filter)
         table.model().select()
     else:
         self.fill_table_mincut_management(self.tbl_mincut_edit, self.schema_name + "." + tablename)
Пример #27
0
    def init_config_form(self):
        """ Custom form initial configuration """

        # Define class variables
        self.field_id = "gully_id"
        self.id = utils_giswater.getWidgetText(self.field_id, False)
        self.filter = self.field_id + " = '" + str(self.id) + "'"
        self.gully_type = utils_giswater.getWidgetText("arccat_id", False)
        self.gratecat_id = utils_giswater.getWidgetText("gratecat_id", False)

        # Get widget controls
        self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")
        self.tbl_element = self.dialog.findChild(QTableView, "tbl_element")
        self.tbl_document = self.dialog.findChild(QTableView, "tbl_document")
        self.tbl_event = self.dialog.findChild(QTableView, "tbl_event_gully")

        feature = self.feature
        layer = self.iface.activeLayer()

        # Toolbar actions
        action = self.dialog.findChild(QAction, "actionEnabled")
        action.setChecked(layer.isEditable())
        self.dialog.findChild(QAction, "actionZoom").triggered.connect(
            partial(self.action_zoom_in, feature, self.canvas, layer))
        self.dialog.findChild(QAction, "actionCentered").triggered.connect(
            partial(self.action_centered, feature, self.canvas, layer))
        self.dialog.findChild(QAction, "actionEnabled").triggered.connect(
            partial(self.action_enabled, action, layer))
        self.dialog.findChild(QAction, "actionZoomOut").triggered.connect(
            partial(self.action_zoom_out, feature, self.canvas, layer))
        # self.dialog.findChild(QAction, "actionHelp").triggered.connect(partial(self.action_help, 'ud', 'gully'))
        self.dialog.findChild(QAction, "actionLink").triggered.connect(
            partial(self.check_link, True))

        # TODO: Manage custom fields
        tab_custom_fields = 1
        self.manage_custom_fields(tab_to_remove=tab_custom_fields)

        # Manage tab signal
        self.tab_element_loaded = False
        self.tab_document_loaded = False
        self.tab_om_loaded = False
        self.tab_main.currentChanged.connect(self.tab_activation)
Пример #28
0
 def reload_qtable(self, dialog, geom_type, plan_om):
     """ Reload QtableView """
     
     value = utils_giswater.getWidgetText(dialog, dialog.psector_id)
     sql = ("SELECT * FROM " + self.schema_name + "." + plan_om + "_psector_x_" + geom_type + ""
            " WHERE psector_id = '" + str(value) + "'")
     qtable = utils_giswater.getWidget(dialog, 'tbl_psector_x_' + geom_type)
     self.fill_table_by_query(qtable, sql)
     self.set_table_columns(dialog, qtable, plan_om + "_psector_x_"+geom_type)
     self.refresh_map_canvas()
Пример #29
0
 def update_location_cmb(self):
     element_type = utils_giswater.getWidgetText(self.dlg_add_element, self.dlg_add_element.element_type)
     sql = ("SELECT location_type FROM " + self.schema_name + ".man_type_location"
            " WHERE feature_type = 'ELEMENT' "
            " AND (featurecat_id = '"+str(element_type)+"' OR featurecat_id is null)"
            " ORDER BY location_type")
     rows = self.controller.get_rows(sql, log_sql=True, commit=self.autocommit)
     utils_giswater.fillComboBox(self.dlg_add_element, "location_type", rows)
     if rows:
         utils_giswater.setCurrentIndex(self.dlg_add_element, "location_type", 0)
Пример #30
0
    def workcat_filter_by_text(self, table, widget_txt):

        result_select = utils_giswater.getWidgetText(widget_txt)
        if result_select != 'null':
            expr = " feature_id LIKE '%" + result_select + "%'"
            # Refresh model with selected filter
            table.model().setFilter(expr)
            table.model().select()
        else:
            self.workcat_fill_table(self.workcat_id)
Пример #31
0
    def network_zoom(self, network_code, network_geom_type):
        """ Zoom feature with the code set in 'network_code' of the layer set in 'network_geom_type' """
        
        # Get selected code from combo
        element = utils_giswater.getWidgetText(network_code)
        if element == 'null':
            return

        # Split element. [0]: feature_id, [1]: cat_feature_id
        row = element.split(' ', 1)
        feature_id = str(row[0])
        cat_feature_id = str(row[1])

        # Get selected layer
        geom_type = utils_giswater.getWidgetText(network_geom_type).lower()
        if geom_type == "null":
            sql = ("SELECT feature_type FROM " + self.controller.schema_name + ".cat_feature"
                   " WHERE id = '" + cat_feature_id + "'")
            row = self.controller.get_row(sql)
            if not row:
                return
            geom_type = row[0].lower()
        fieldname = geom_type + "_id"

        # Check if the expression is valid
        aux = fieldname + " = '" + feature_id + "'"
        expr = QgsExpression(aux)
        if expr.hasParserError():
            message = expr.parserErrorString() + ": " + aux
            self.controller.show_warning(message)
            return

        for value in self.feature_cat.itervalues():
            if value.type.lower() == geom_type:
                layer = self.controller.get_layer_by_layername(value.layername)
                if layer:
                    it = layer.getFeatures(QgsFeatureRequest(expr))
                    ids = [i.id() for i in it]
                    layer.selectByIds(ids)
                    # If any feature found, zoom it and exit function
                    if layer.selectedFeatureCount() > 0:
                        self.zoom_to_selected_features(layer)
                        return
    def fill_filter3(self, wsoftware, geom_type):

        # Get values from filters
        mats = utils_giswater.getWidgetText(self.dlg_cat.matcat_id)
        filter2 = utils_giswater.getWidgetText(self.dlg_cat.filter2)

        # Set SQL query
        sql_where = ""
        if wsoftware == 'ws' and geom_type != 'connec':
            sql = "SELECT " + self.field3
            sql += " FROM (SELECT DISTINCT(regexp_replace(trim(' nm' FROM " + self.field3 + "),'-','', 'g')) as x, " + self.field3
        elif wsoftware == 'ws' and geom_type == 'connec':
            sql = "SELECT DISTINCT(TRIM(TRAILING ' ' from " + self.field3 + ")) as " + self.field3
        else:
            sql = "SELECT DISTINCT(" + self.field3 + ")"
        sql += " FROM " + self.schema_name + ".cat_" + geom_type

        # Build SQL filter
        if wsoftware == 'ws' and self.node_type_text is not None:
            sql_where = " WHERE " + geom_type + "type_id = '" + self.node_type_text + "'"
            
        if mats != "null":
            if sql_where == "":
                sql_where = " WHERE"
            else:
                sql_where += " AND"
            sql_where += " matcat_id = '" + mats + "'"
            
        if filter2 != "null":
            if sql_where == "":
                sql_where = " WHERE"
            else:
                sql_where += " AND"
            sql_where += " " + self.field2 + " = '" + filter2 + "'"
        if wsoftware == 'ws' and geom_type != 'connec':
            sql += sql_where + " ORDER BY x) AS " + self.field3
        else:
            sql += sql_where + " ORDER BY " + self.field3

        rows = self.controller.get_rows(sql)
        utils_giswater.fillComboBox(self.dlg_cat.filter3, rows)
        
        self.fill_catalog_id(wsoftware, geom_type)        
Пример #33
0
    def filter_by_text(self, table, widget_txt, tablename):

        result_select = utils_giswater.getWidgetText(widget_txt)
        if result_select != 'null':
            expr = " name ILIKE '%" + result_select + "%'"
            # Refresh model with selected filter
            table.model().setFilter(expr)
            table.model().select()
        else:
            self.fill_table(table, tablename)
Пример #34
0
    def workcat_filter_by_text(self, qtable, widget_txt, table_name, workcat_id):

        result_select = utils_giswater.getWidgetText(widget_txt)
        if result_select != 'null':
            expr = "workcat_id = '" + str(workcat_id) + "'"
            expr += "and feature_id ILIKE '%" + str(result_select) + "%'"
        else:
            expr = "workcat_id ILIKE '%" + str(workcat_id) + "%'"
        self.workcat_fill_table(qtable, table_name, expr=expr)
        self.set_table_columns(qtable, table_name)
 def refresh_table(self, widget):
     """ Refresh qTableView 'selected_rows' """
     
     widget.selectAll()
     selected_list = widget.selectionModel().selectedRows()
     widget.clearSelection()
     for i in range(0, len(selected_list)):
         row = selected_list[i].row()
         if str(widget.model().record(row).value('psector_id')) != utils_giswater.getWidgetText('psector_id'):
             widget.hideRow(i)
Пример #36
0
    def reload_table_visit(self):
        feature_type = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2)
        object_id = utils_giswater.getWidgetText(self.dlg_lot,
                                                 self.dlg_lot.txt_filter)
        visit_start = self.dlg_lot.date_event_from.date()
        visit_end = self.dlg_lot.date_event_to.date()
        # Get selected dates
        date_from = visit_start.toString('yyyyMMdd 00:00:00')
        date_to = visit_end.toString('yyyyMMdd 23:59:59')
        if date_from > date_to:
            message = "Selected date interval is not valid"
            self.controller.show_warning(message)
            return
        visit_class_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
        sql = ("SELECT visitclass_id, formname, tablename FROM " +
               self.schema_name + ".config_api_visit "
               " WHERE visitclass_id ='" + str(visit_class_id) + "'")
        row = self.controller.get_row(sql, log_sql=False)

        table_name = row['tablename']
        if self.schema_name not in table_name:
            table_name = self.schema_name + "." + table_name

        # Create interval dates
        format_low = 'yyyy-MM-dd 00:00:00.000'
        format_high = 'yyyy-MM-dd 23:59:59.999'
        interval = "'{}'::timestamp AND '{}'::timestamp".format(
            visit_start.toString(format_low), visit_end.toString(format_high))

        expr_filter = ("(startdate BETWEEN {0}) AND (enddate BETWEEN {0})".
                       format(interval))
        if object_id != 'null':
            expr_filter += " AND " + str(
                feature_type) + "_id::TEXT ILIKE '%" + str(object_id) + "%'"

        expr_filter += " AND " + str(feature_type) + "_id IN ('0', "
        for i in range(len(self.ids)):
            expr_filter += "'" + str(self.ids[i]) + "', "
        expr_filter = expr_filter[:-2] + ")"

        model = QSqlTableModel()
        model.setTable(table_name)
        model.setEditStrategy(QSqlTableModel.OnManualSubmit)
        model.setFilter(expr_filter)
        model.sort(0, 1)
        model.select()

        # Check for errors
        if model.lastError().isValid():
            self.controller.show_warning(model.lastError().text())

        # Attach model to table view
        self.dlg_lot.tbl_visit.setModel(model)
Пример #37
0
    def insert_or_update_config_param_curuser(self, dialog, widget, parameter, tablename):
        """ Insert or update values in tables with current_user control """

        sql = 'SELECT * FROM ' + self.schema_name + '.' + tablename
        sql += ' WHERE "cur_user" = current_user'
        rows = self.controller.get_rows(sql)
        exist_param = False
        if type(widget) != QDateEdit:
            if utils_giswater.getWidgetText(dialog, widget) != "":
                for row in rows:
                    if row[1] == parameter:
                        exist_param = True
                if exist_param:
                    sql = "UPDATE " + self.schema_name + "." + tablename + " SET value="
                    if widget.objectName() != 'state_vdefault':
                        sql += "'" + utils_giswater.getWidgetText(dialog, widget) + "' WHERE parameter='" + parameter + "'"
                    else:
                        sql += ("(SELECT id FROM " + self.schema_name + ".value_state"
                                " WHERE name = '" + utils_giswater.getWidgetText(dialog, widget) + "')"
                                " WHERE parameter = 'state_vdefault'")
                else:
                    sql = "INSERT INTO " + self.schema_name + "." + tablename + "(parameter, value, cur_user)"
                    if widget.objectName() != 'state_vdefault':
                        sql += " VALUES ('" + parameter + "', '" + utils_giswater.getWidgetText(dialog, widget) + "', current_user)"
                    else:
                        sql += (" VALUES ('" + parameter + "',"
                                " (SELECT id FROM " + self.schema_name + ".value_state"
                                " WHERE name ='" + utils_giswater.getWidgetText(dialog, widget) + "'), current_user)")
        else:
            for row in rows:
                if row[1] == parameter:
                    exist_param = True
            if exist_param:
                sql = "UPDATE " + self.schema_name + "." + tablename + " SET value="
                _date = widget.dateTime().toString('yyyy-MM-dd')
                sql += "'" + str(_date) + "' WHERE parameter='" + parameter + "'"
            else:
                sql = "INSERT INTO " + self.schema_name + "." + tablename + "(parameter, value, cur_user)"
                _date = widget.dateTime().toString('yyyy-MM-dd')
                sql += " VALUES ('" + parameter + "', '" + _date + "', current_user)"
                
        self.controller.execute_sql(sql)
Пример #38
0
    def open_web_browser(self, dialog, widget=None):
        """ Display url using the default browser """

        if widget is not None:
            url = utils_giswater.getWidgetText(dialog, widget)
            if url == 'null':
                url = 'www.giswater.org'
        else:
            url = 'www.giswater.org'

        webbrowser.open(url)
    def fill_tab_custom_fields(self):
        """ Fill tab 'Custom fields' """

        arc_type = self.dialog.findChild(QComboBox, 'arc_type')
        cat_feature_id = utils_giswater.getWidgetText(self.dialog, arc_type)
        if cat_feature_id.lower() == "null":
            msg = "In order to manage custom fields, that field has to be set"
            self.controller.show_info(msg, parameter="'arc_type'", duration=10)
            return False
        self.manage_custom_fields(cat_feature_id)
        return True
Пример #40
0
    def __init__(self, dialog, layer, feature):
        """ Constructor class """

        self.geom_type = "node"
        self.field_id = "node_id"
        self.id = utils_giswater.getWidgetText(self.field_id, False)
        super(ManNodeDialog, self).__init__(dialog, layer, feature)
        self.init_config_form()
        self.controller.manage_translation('ud_man_node', dialog)
        if dialog.parent():
            dialog.parent().setFixedSize(625, 660)
def init_config():
    
    # Manage visibility     
    feature_dialog.dialog.findChild(QComboBox, "connecat_id").setVisible(False)    
    feature_dialog.dialog.findChild(QComboBox, "cat_connectype_id").setVisible(False)    
    
    # Manage 'connecat_id'
    connecat_id = utils_giswater.getWidgetText("connecat_id")
    feature_dialog.dialog.findChild(QComboBox, "connecat_id_dummy").activated.connect(feature_dialog.change_connec_cat)          
    utils_giswater.setSelectedItem("connecat_id_dummy", connecat_id)   
    utils_giswater.setSelectedItem("connecat_id", connecat_id)   
    
    # Manage 'connec_type'
    cat_connectype_id = utils_giswater.getWidgetText("cat_connectype_id")
    utils_giswater.setSelectedItem("cat_connectype_id_dummy", cat_connectype_id)  
    feature_dialog.dialog.findChild(QComboBox, "cat_connectype_id_dummy").activated.connect(feature_dialog.change_connec_type_id)  
    feature_dialog.change_connec_type_id(-1)      
    
    # Set button signals      
    feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.update_sum)            
    feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)      
Пример #42
0
 def change_node_type_id(self, index):
     ''' Define and execute query to populate combo 'cat_nodetype_id' '''
     node_type_id = utils_giswater.getWidgetText("node_type_dummy", False)    
     if node_type_id:        
         utils_giswater.setWidgetText("node_type", node_type_id)    
         sql = "SELECT id FROM "+self.schema_name+".cat_node"
         sql+= " WHERE nodetype_id = '"+node_type_id+"' ORDER BY id"
         rows = self.dao.get_rows(sql)    
         utils_giswater.fillComboBox("nodecat_id_dummy", rows, False)    
         if index == -1:  
             utils_giswater.setWidgetText("nodecat_id_dummy", self.nodecat_id)    
         self.change_node_cat()
Пример #43
0
    def mg_result_selector_accept(self):
        ''' Update current values to the table '''
           
        # Get new values from widgets of type QComboBox
        rpt_selector_result_id = utils_giswater.getWidgetText("rpt_selector_result_id")
        rpt_selector_compare_id = utils_giswater.getWidgetText("rpt_selector_compare_id")

        # Delete previous values
        # Set new values to tables 'rpt_selector_result' and 'rpt_selector_compare'
        sql= "DELETE FROM "+self.schema_name+".rpt_selector_result" 
        self.dao.execute_sql(sql)
        sql= "DELETE FROM "+self.schema_name+".rpt_selector_compare" 
        self.dao.execute_sql(sql)
        sql= "INSERT INTO "+self.schema_name+".rpt_selector_result VALUES ('"+rpt_selector_result_id+"');"
        self.dao.execute_sql(sql)
        sql= "INSERT INTO "+self.schema_name+".rpt_selector_compare VALUES ('"+rpt_selector_compare_id+"');"
        self.dao.execute_sql(sql)

        # Show message to user
        message = "Values has been updated"
        self.controller.show_info(message, context_name='ui_message') 
        self.close_dialog(self.dlg) 
Пример #44
0
 def mg_change_elem_type_get_value(self, index):   #@UnusedVariable
     ''' Just select item to 'real' combo 'nodecat_id' (that is hidden) ''' 
     
     # Get selected value from 1st combobox
     self.value_combo1 = utils_giswater.getWidgetText("node_type_type_new")   
     
     # When value is selected, enabled 2nd combo box
     if self.value_combo1 != 'null':
         self.dlg.node_node_type_new.setEnabled(True)  
         # Fill 2nd combo_box-custom node type
         sql = "SELECT DISTINCT(id) FROM "+self.schema_name+".node_type WHERE type='"+self.value_combo1+"'"
         rows = self.dao.get_rows(sql)
         utils_giswater.fillComboBox("node_node_type_new", rows)
Пример #45
0
def init_config():
     
    feature_dialog.dialog.findChild(QComboBox, "arccat_id").setVisible(False)         
    arccat_id = utils_giswater.getWidgetText("arccat_id", False)
    feature_dialog.change_arc_type()  
    feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id").activated.connect(feature_dialog.change_arc_type)    
    feature_dialog.dialog.findChild(QComboBox, "arccat_id_dummy").activated.connect(feature_dialog.change_arc_cat)          
    utils_giswater.setSelectedItem("arccat_id_dummy", arccat_id)            
    utils_giswater.setSelectedItem("arccat_id", arccat_id)            
    
    feature_dialog.dialog.findChild(QComboBox, "epa_type").activated.connect(feature_dialog.change_epa_type)    
    feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save)            
    feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)        
Пример #46
0
def init_config():
    
    # Manage visibility 
    feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id").setVisible(False)    
    feature_dialog.dialog.findChild(QComboBox, "arccat_id").setVisible(False)    
    
    # Manage 'arccat_id'
    nodecat_id = utils_giswater.getWidgetText("arccat_id")
    feature_dialog.dialog.findChild(QComboBox, "arccat_id_dummy").activated.connect(feature_dialog.change_arc_cat)          
    utils_giswater.setSelectedItem("arcccat_id_dummy", nodecat_id)   
    utils_giswater.setSelectedItem("nodecat_id", nodecat_id)   
    
    # Manage 'cat_arctype_id'
    arc_type_id = utils_giswater.getWidgetText("cat_arctype_id")
    utils_giswater.setSelectedItem("cat_arctype_id_dummy", arc_type_id)    
    feature_dialog.dialog.findChild(QComboBox, "cat_arctype_id_dummy").activated.connect(feature_dialog.change_arc_type_id)  
    feature_dialog.change_arc_type_id(-1)      
      
    # Set 'epa_type' and button signals      
    feature_dialog.dialog.findChild(QComboBox, "epa_type").activated.connect(feature_dialog.change_epa_type)  
    feature_dialog.dialog.findChild(QPushButton, "btn_accept").clicked.connect(feature_dialog.save)            
    feature_dialog.dialog.findChild(QPushButton, "btn_close").clicked.connect(feature_dialog.close)      
Пример #47
0
    def change_arc_type_id(self, index):
        ''' Define and execute query to populate combo 'cat_arctype_id' '''

        arc_type_id = utils_giswater.getWidgetText("cat_arctype_id", False)    
        if arc_type_id:        
            utils_giswater.setWidgetText("cat_arctype_id", arc_type_id)    
            sql = "SELECT id FROM "+self.schema_name+".cat_arc"
            sql+= " WHERE arctype_id = '"+arc_type_id+"' ORDER BY id"
            rows = self.dao.get_rows(sql)    
            utils_giswater.fillComboBox("arccat_id_dummy", rows, False)    
            if index == -1:  
                utils_giswater.setWidgetText("arccat_id_dummy", self.arccat_id)    
            self.change_arc_cat()     
Пример #48
0
 def ed_add_file_accept(self): 
     ''' Insert or update document. Add document to selected feature '''  
     
     # Get values from dialog
     doc_id = utils_giswater.getWidgetText("doc_id") 
     doc_type = utils_giswater.getWidgetText("doc_type")   
     tagcat_id = utils_giswater.getWidgetText("tagcat_id")  
     observ = utils_giswater.getWidgetText("observ")
     path = utils_giswater.getWidgetText("path")
     
     # Check if this document already exists
     sql = "SELECT DISTINCT(id) FROM "+self.schema_name+".doc WHERE id = '"+doc_id+"'" 
     row = self.dao.get_row(sql)
     if row:
         answer = self.controller.ask_question("Are you sure you want change the data?")
         if answer:
             sql = "UPDATE "+self.schema_name+".doc "
             sql+= " SET doc_type = '"+doc_type+"', tagcat_id= '"+tagcat_id+"',observ = '"+observ+"', path = '"+path+"'"
             sql+= " WHERE id = '"+doc_id+"'" 
             self.dao.execute_sql(sql) 
         else:
             self.close_dialog(self.dlg) 
     else:
         sql = "INSERT INTO "+self.schema_name+".doc (id, doc_type, path, observ, tagcat_id) "
         sql+= " VALUES ('"+doc_id+"', '"+doc_type+"', '"+path+"', '"+observ+"', '"+tagcat_id+"')"
         status = self.controller.execute_sql(sql) 
         if not status:
             message = "Error inserting element in table, you need to review data"
             self.controller.show_warning(message, context_name='ui_message')
             return
     
     # Add document to selected feature
     self.ed_add_to_feature("doc", doc_id)
        
     # Show message to user
     message = "Values has been updated"
     self.controller.show_info(message, context_name='ui_message')
     self.close_dialog()  
Пример #49
0
 def save_tab_analysis(self):
     ''' Save tab from tab 'Analysis' '''   
                  
     #super(ArcDialog, self).save_tab_analysis()
     if self.epa_type == 'PIPE':
         values = []            
         sql = "UPDATE "+self.schema_name+"."+self.epa_table+" SET "
         for i in range(len(self.fields_pipe)):
             widget_name = self.epa_table+"_"+self.fields_pipe[i]     
             value = utils_giswater.getWidgetText(widget_name, True)     
             values.append(value)
             sql+= self.fields_pipe[i]+" = "+str(values[i])+", "
         sql = sql[:-2]      
         sql+= " WHERE "+self.field_id+" = '"+self.id+"'"        
         self.dao.execute_sql(sql)        
Пример #50
0
    def init_config_form(self):
        """ Custom form initial configuration """

        # Define local variables
        context_name = "ud_arc"
        table_element = "v_ui_element_x_arc"
        table_document = "v_ui_doc_x_arc"

        # Define class variables
        self.field_id = "arc_id"
        self.id = utils_giswater.getWidgetText(self.field_id, False)
        self.filter = self.field_id + " = '" + str(self.id) + "'"
        self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")
        self.tbl_element = self.dialog.findChild(QTableView, "tbl_element")
        self.tbl_document = self.dialog.findChild(QTableView, "tbl_document")

        # Manage tab visibility
        self.set_tabs_visibility()

        # Manage i18n
        self.translate_form(context_name)

        # Load data from related tables
        # self.load_data()

        # Set layer in editing mode
        self.layer.startEditing()

        # Fill the element table
        self.fill_table(self.tbl_element, self.schema_name + "." + table_element, self.filter)

        # Configuration of element table
        self.set_configuration(self.tbl_element, table_element)

        # Fill the tab Document
        self.fill_tbl_document(self.tbl_document, self.schema_name + "." + table_document, self.filter)

        # Configuration of document table
        self.set_configuration(self.tbl_document, table_document)

        # Set signals
        btn_element_delete = self.dialog.findChild(QPushButton, "btn_element_delete")
        btn_doc_delete = self.dialog.findChild(QPushButton, "btn_doc_delete")
        if btn_element_delete:
            btn_element_delete.clicked.connect(partial(self.delete_records, self.tbl_element, table_element))
        if btn_doc_delete:
            btn_doc_delete.clicked.connect(partial(self.delete_records, self.tbl_document, table_document))
Пример #51
0
    def ed_add_file_autocomplete(self): 
        ''' Once we select 'element_id' using autocomplete, fill widgets with current values '''

        self.dlg.doc_id.setCompleter(self.completer)
        doc_id = utils_giswater.getWidgetText("doc_id") 
        
        # Get values from database           
        sql = "SELECT doc_type, tagcat_id, observ, path"
        sql+= " FROM "+self.schema_name+".doc" 
        sql+= " WHERE id = '"+doc_id+"'"
        row = self.dao.get_row(sql)
        
        # Fill widgets
        columns_length = self.dao.get_columns_length()
        for i in range(0, columns_length):
            column_name = self.dao.get_column_name(i)
            utils_giswater.setWidgetText(column_name, row[column_name])       
Пример #52
0
    def ed_add_el_autocomplete(self):    
        ''' Once we select 'element_id' using autocomplete, fill widgets with current values '''

        self.dlg.element_id.setCompleter(self.completer)
        element_id = utils_giswater.getWidgetText("element_id") 
        
        # Get values from database       
        sql = "SELECT elementcat_id, location_type, ownercat_id, state, workcat_id," 
        sql+= " buildercat_id, annotation, observ, comment, link, verified, rotation"
        sql+= " FROM "+self.schema_name+".element" 
        sql+= " WHERE element_id = '"+element_id+"'"
        row = self.dao.get_row(sql)
        
        # Fill widgets
        columns_length = self.dao.get_columns_length()
        for i in range(0, columns_length):
            column_name = self.dao.get_column_name(i)
            utils_giswater.setWidgetText(column_name, row[column_name]) 
Пример #53
0
    def mg_change_elem_type_get_value_2(self, index):    
        ''' Just select item to 'real' combo 'nodecat_id' (that is hidden) ''' 

        if index == -1:
            return
        
        # Get selected value from 2nd combobox
        self.value_combo2 = utils_giswater.getWidgetText("node_node_type_new")         
        
        # When value is selected, enabled 3rd combo box
        if self.value_combo2 != 'null':
            # Get selected value from 2nd combobox
            self.dlg.node_nodecat_id.setEnabled(True)
            # Fill 3rd combo_box-catalog_id
            sql = "SELECT DISTINCT(id)"
            sql+= " FROM "+self.schema_name+".cat_node"
            sql+= " WHERE nodetype_id='"+self.value_combo2+"'"
            rows = self.dao.get_rows(sql)
            utils_giswater.fillComboBox("node_nodecat_id", rows)     
Пример #54
0
 def mg_config_accept_table(self, tablename, columns):
     ''' Update values of selected 'tablename' with the content of 'columns' '''
     
     if columns is not None:       
         sql = "UPDATE "+self.schema_name+"."+tablename+" SET "         
         for column_name in columns:
             if column_name != 'id':
                 widget_type = utils_giswater.getWidgetType(column_name)
                 if widget_type is QCheckBox:
                     value = utils_giswater.isChecked(column_name)                      
                 else:
                     value = utils_giswater.getWidgetText(column_name)
                 if value is None or value == 'null':
                     sql+= column_name+" = null, "     
                 else:
                     if type(value) is not bool:
                         value = value.replace(",", ".")
                     sql+= column_name+" = '"+str(value)+"', "           
         
         sql = sql[:-2]
         self.dao.execute_sql(sql)
                     
             
Пример #55
0
 def init_config_connec(self):
     ''' Custom form initial configuration for 'Connec' '''
     
     # Define class variables
     self.field_id = "connec_id"
     self.id = utils_giswater.getWidgetText(self.field_id, False)     
     
     # Get widget controls
     self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis")            
     self.tab_event = self.dialog.findChild(QTabWidget, "tab_event")         
     self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")     
     
     # Manage tab visibility
     self.set_tabs_visibility()                
     
     # Manage i18n
     self.translate_form('ws_connec')        
     
     # Load data from related tables
     self.load_data()
     
     # Set layer in editing mode
     self.layer.startEditing()
Пример #56
0
    def change_node_type_id(self, index):
        """ Define and execute query to populate combo 'cat_nodetype_id' """

        node_type_id = utils_giswater.getWidgetText("node_type_dummy", False)
        if node_type_id:
            utils_giswater.setWidgetText("node_type", node_type_id)
            sql = "SELECT id FROM " + self.schema_name + ".cat_node"
            sql += " WHERE nodetype_id = '" + node_type_id + "' ORDER BY id"
            rows = self.dao.get_rows(sql)
            utils_giswater.fillComboBox("nodecat_id_dummy", rows, False)
            if index == -1:
                utils_giswater.setWidgetText("nodecat_id_dummy", self.nodecat_id)
            self.change_node_cat()

            if self.loaded:
                sql = "SELECT epa_default FROM " + self.schema_name + ".node_type"
                sql += " WHERE id = '" + node_type_id + "'"
                rows = self.dao.get_rows(sql)
                utils_giswater.setWidgetText("epa_type", rows[0][0])
                utils_giswater.setSelectedItem("epa_type", rows[0][0])
                self.change_epa_type(-1)

            else:
                self.loaded = True
    def init_config_form(self):
        ''' Custom form initial configuration '''

        # Define local variables
        context_name = "ws_connec"    
        table_element = "v_ui_element_x_connec" 
        table_document = "v_ui_doc_x_connec"   
        table_hydrometer = "v_rtc_hydrometer"   
        table_hydrometer_epanet = "v_edit_rtc_hydro_data_x_connec"                     
        
        # Define class variables
        self.field_id = "connec_id"        
        self.id = utils_giswater.getWidgetText(self.field_id, False)  
        self.filter = self.field_id+" = '"+str(self.id)+"'"                    
        self.connec_type = utils_giswater.getWidgetText("cat_connectype_id", False)        
        self.connecat_id = utils_giswater.getWidgetText("connecat_id", False)      
        
        # Get widget controls
        self.tab_analysis = self.dialog.findChild(QTabWidget, "tab_analysis")            
        self.tab_event = self.dialog.findChild(QTabWidget, "tab_event")  
        self.tab_event_2 = self.dialog.findChild(QTabWidget, "tab_event_2")        
        self.tab_main = self.dialog.findChild(QTabWidget, "tab_main")      
        self.tbl_info = self.dialog.findChild(QTableView, "tbl_info")    
        self.tbl_document = self.dialog.findChild(QTableView, "tbl_connec")             
        self.tbl_dae = self.dialog.findChild(QTableView, "tbl_dae")   
        self.tbl_dae_2 = self.dialog.findChild(QTableView, "tbl_dae_2")    
             
        # Manage tab visibility
        self.set_tabs_visibility()
        
        # Manage i18n
        self.translate_form(context_name)        
        
        # Define and execute query to populate combo 'cat_connectype_id_dummy' 
        self.fill_connec_type_id()
        
        # Load data from related tables
        self.load_data()
        
        # Set layer in editing mode
        self.layer.startEditing()
        
        # Fill the info table
        self.fill_table(self.tbl_info, self.schema_name+"."+table_element, self.filter)
        
        # Configuration of info table
        self.set_configuration(self.tbl_info, table_element)
        
        # Fill the tab Document
        self.fill_tbl_document(self.tbl_document, self.schema_name+"."+table_document, self.filter)
        
        # Configuration of table Document
        self.set_configuration(self.tbl_document, table_document)
        
        # Fill tab Hydrometer | feature
        self.fill_tbl_hydrometer(self.tbl_dae, self.schema_name+"."+table_hydrometer, self.filter)
        
        # Configuration of table Hydrometer | feature
        self.set_configuration(self.tbl_dae, table_hydrometer)
        
        # Fill tab Hydrometer | epanet
        self.fill_tbl_hydrometer_epanet(self.tbl_dae_2, self.schema_name+"."+table_hydrometer_epanet, self.filter)

        # Configuration of table Hydrometer | epanet
        self.set_configuration(self.tbl_dae_2, table_hydrometer_epanet)
        
        # Set signals                  
        self.dialog.findChild(QPushButton, "delete_row_info").clicked.connect(partial(self.delete_records, self.tbl_info, table_element))                 
        self.dialog.findChild(QPushButton, "delete_row_doc").clicked.connect(partial(self.delete_records, self.tbl_document, table_document))    
        self.dialog.findChild(QPushButton, "btn_delete_hydrometer").clicked.connect(partial(self.delete_records_dae, self.tbl_dae, table_hydrometer))               
        self.dialog.findChild(QPushButton, "btn_add_hydrometer").clicked.connect(self.insert_records)
Пример #58
0
 def change_arc_cat(self):
     ''' Just select item to 'real' combo 'arccat_id' (that is hidden) '''
     arccat_id_dummy = utils_giswater.getWidgetText("arccat_id_dummy")
     utils_giswater.setWidgetText("arccat_id", arccat_id_dummy)           
Пример #59
0
 def change_node_cat(self):
     """ Just select item to 'real' combo 'nodecat_id' (that is hidden) """
     nodecat_id_dummy = utils_giswater.getWidgetText("nodecat_id_dummy")
     utils_giswater.setWidgetText("nodecat_id", nodecat_id_dummy)
Пример #60
0
    def ed_add_element_accept(self):
           
        # Get values from dialog
        element_id = utils_giswater.getWidgetText("element_id")
        elementcat_id = utils_giswater.getWidgetText("elementcat_id")  
        state = utils_giswater.getWidgetText("state")   
        annotation = utils_giswater.getWidgetText("annotation")
        observ = utils_giswater.getWidgetText("observ")
        comment = utils_giswater.getWidgetText("comment")
        location_type = utils_giswater.getWidgetText("location_type")
        workcat_id = utils_giswater.getWidgetText("workcat_id")
        buildercat_id = utils_giswater.getWidgetText("buildercat_id")
        ownercat_id = utils_giswater.getWidgetText("ownercat_id")
        rotation = utils_giswater.getWidgetText("rotation")
        link = utils_giswater.getWidgetText("link")
        verified = utils_giswater.getWidgetText("verified")

        # Check if we already have data with selected element_id
        sql = "SELECT DISTINCT(element_id) FROM "+self.schema_name+".element WHERE element_id = '"+element_id+"'"    
        row = self.dao.get_row(sql)
        if row:
            answer = self.controller.ask_question("Are you sure you want change the data?")
            if answer:
                sql = "UPDATE "+self.schema_name+".element"
                sql+= " SET element_id = '"+element_id+"', elementcat_id= '"+elementcat_id+"',state = '"+state+"', location_type = '"+location_type+"'"
                sql+= ", workcat_id= '"+workcat_id+"',buildercat_id = '"+buildercat_id+"', ownercat_id = '"+ownercat_id+"'"
                sql+= ", rotation= '"+rotation+"',comment = '"+comment+"', annotation = '"+annotation+"', observ= '"+observ+"',link = '"+link+"', verified = '"+verified+"'"
                sql+= " WHERE element_id = '"+element_id+"'" 
                self.dao.execute_sql(sql)  
            else:
                self.close_dialog(self.dlg)
        else:
            sql = "INSERT INTO "+self.schema_name+".element (element_id, elementcat_id, state, location_type"
            sql+= ", workcat_id, buildercat_id, ownercat_id, rotation, comment, annotation, observ, link, verified) "
            sql+= " VALUES ('"+element_id+"', '"+elementcat_id+"', '"+state+"', '"+location_type+"', '"
            sql+= workcat_id+"', '"+buildercat_id+"', '"+ownercat_id+"', '"+rotation+"', '"+comment+"', '"
            sql+= annotation+"','"+observ+"','"+link+"','"+verified+"')"
            status = self.controller.execute_sql(sql) 
            if not status:
                message = "Error inserting element in table, you need to review data"
                self.controller.show_warning(message, context_name='ui_message') 
                return
        
        # Add document to selected feature
        self.ed_add_to_feature("element", element_id)
                
        # Show message to user
        message = "Values has been updated"
        self.controller.show_info(message, context_name='ui_message')
        self.close_dialog()