Пример #1
0
 def _table_columns(self, table_name):
     """
     Return the column names for a given table_name name.
     :param table_name: Table name
     :type table_name: str
     :return: Collection of column names. If not found then an empty list is returned.
     :rtype: list
     """
     return table_column_names(table_name)
Пример #2
0
    def _load_source_table_fields(self, sel):
        self.cbo_referencing_col.clear()

        if not sel:
            return

        columns_names = table_column_names(sel)

        self.cbo_referencing_col.clear()
        self.cbo_referencing_col.addItem("")
        self.cbo_referencing_col.addItems(columns_names)
    def _loadFields(self):
        """
        Load labeling fields/columns.
        """
        if self._dsName == "":
            self.cboLabelField.clear()
            return

        cols = table_column_names(self._dsName)
        spatialCols = table_column_names(self._dsName, True)

        spSet = set(spatialCols)
        nonSpatialCols = [c for c in cols if c not in spSet]

        if len(nonSpatialCols) == 0:
            return

        self.cboLabelField.clear()
        self.cboLabelField.addItem("")

        self.cboLabelField.addItems(nonSpatialCols)
Пример #4
0
 def _loadFields(self):
     """
     Load labeling fields/columns.
     """
     if not self._dsName:
         self.cboLabelField.clear()
         return
     
     cols = table_column_names(self._dsName)
     spatialCols = table_column_names(self._dsName,True)
     
     spSet = set(spatialCols)
     nonSpatialCols = [c for c in cols if c not in spSet]
     
     if len(nonSpatialCols) == 0:
         return
     
     self.cboLabelField.clear()
     self.cboLabelField.addItem("")
     
     self.cboLabelField.addItems(nonSpatialCols)
     
Пример #5
0
 def loadColumns(self,table):
     #Load textual and spatial (if available) columns
     #Get spatial columns first        
     spColumns = table_column_names(table,True)
     self.cboSpatialCols_2.clear()
     self.cboSpatialCols_2.addItems(spColumns)
     
     #Textual Columns
     self.lstSrcCols_2.clear()
     self.allCols = table_column_names(table)
     
     for sc in spColumns:            
         colIndex = getIndex(self.allCols,sc)
         if colIndex != -1:
             self.allCols.remove(sc)    
                                     
     for col in self.allCols:            
         tabItem = QListWidgetItem(col,self.lstSrcCols_2)
         tabItem.setCheckState(Qt.Unchecked)
         tabItem.setIcon(QIcon(":/plugins/stdm/images/icons/column.png"))
         self.lstSrcCols_2.addItem(tabItem)   
            
     if len(spColumns) > 0:
         self.cboSpatialCols_2.setEnabled(True)
Пример #6
0
    def loadTabFields(self,comboItemIndex):
        #Load the associated fields from  specified table name
        if isinstance(comboItemIndex, str) or isinstance(comboItemIndex, unicode):
            comboItemIndex = self.comboBox.findData(comboItemIndex)

            if comboItemIndex == -1:
                QMessageBox.critical(self, QApplication.translate("ReportBuilder", "Report Error"),
                                        QApplication.translate("ReportBuilder","Table does not exist in the drop-down list"))
                return
        self.tabName = self.comboBox.itemData(comboItemIndex)
        self.tabFields = table_column_names(self.tabName)
        self.listWidget.addItems(self.tabFields) 
        
        #Set table name in the Fields Query Builder
        self.lblSqlEntity.setText("Select * FROM " + self.tabName + " WHERE:")   
Пример #7
0
    def on_table_name_changed(self, table):
        """
        Slot raised when table name changes so that the corresponding
        column names can be updated.
        :param table: Name of the current table
        :type table: str
        """
        self.cbo_value_field.clear()
        self.cbo_x_field.clear()

        numeric_cols = numeric_columns(table)
        x_cols = table_column_names(table)

        self.cbo_value_field.addItems(numeric_cols)
        self.cbo_x_field.addItems(x_cols)
Пример #8
0
    def _on_source_table_changed(self, index):
        source_table = self.cbo_source_tables.currentText()

        self.cbo_output_column.clear()

        if source_table:
            ref_table_cols = table_column_names(source_table)

            self.tb_source_trans_cols.set_combo_selection([self._source_cols,
            ref_table_cols])

            #self.cbo_output_column.addItem("")
            self.cbo_output_column.addItems(ref_table_cols)

        else:
            self.tb_source_trans_cols.clear_view()
    def _loadFields(self):
        """
        Load spatial fields/columns of the given data source.
        """
        if self._dsName == "":
            self.cboSpatialFields.clear()
            return

        spatialColumns = table_column_names(self._dsName, True)

        if len(spatialColumns) == 0:
            return

        self.cboSpatialFields.clear()
        self.cboSpatialFields.addItem("")

        self.cboSpatialFields.addItems(spatialColumns)
Пример #10
0
 def _loadFields(self,dataSourceName):
     """
     Load fields/columns of the given data source.
     """
     if dataSourceName == "":
         self.cboDataField.clear()
         return
     
     columnsNames = table_column_names(dataSourceName)
     
     if len(columnsNames) == 0:
         return
     
     self.cboDataField.clear()
     self.cboDataField.addItem("")
     
     self.cboDataField.addItems(columnsNames)
Пример #11
0
 def _loadFields(self):
     """
     Load spatial fields/columns of the given data source.
     """
     if self._dsName == "":
         self.cboSpatialFields.clear()
         return
     
     spatialColumns = table_column_names(self._dsName,True)
     
     if len(spatialColumns) == 0:
         return
     
     self.cboSpatialFields.clear()
     self.cboSpatialFields.addItem("")
     
     self.cboSpatialFields.addItems(spatialColumns)
Пример #12
0
    def _loadFields(self, dataSourceName):
        """
        Load fields/columns of the given data source.
        """
        if dataSourceName == "":
            self.cboDataField.clear()
            return

        columnsNames = table_column_names(dataSourceName)

        if len(columnsNames) == 0:
            return

        self.cboDataField.clear()
        self.cboDataField.addItem("")

        self.cboDataField.addItems(columnsNames)
Пример #13
0
    def load_data_source_fields(self, data_source_name):
        """
        Load fields/columns of the given data source.
        """
        if data_source_name == "":
            self.clear()

            return

        columns_names = table_column_names(data_source_name)

        if len(columns_names) == 0:
            return

        self.cbo_source_field.clear()
        self.cbo_source_field.addItem("")
        self.cbo_source_field.addItems(columns_names)
Пример #14
0
 def assignCols(self):
     #Load source and target columns respectively
     srcCols=self.dataReader.getFields()
     
     for c in srcCols:
         srcItem = QListWidgetItem(c,self.lstSrcFields)
         srcItem.setCheckState(Qt.Unchecked)
         srcItem.setIcon(QIcon(":/plugins/stdm/images/icons/column.png"))
         self.lstSrcFields.addItem(srcItem)
         
     #Destination Columns
     tabIndex = int(self.field("tabIndex"))
     self.targetTab = self.destCheckedItem.text()
     targetCols = table_column_names(self.targetTab)   
         
     #Remove geometry columns in the target columns list
     for gc in self.geomcols:            
         colIndex = getIndex(targetCols,gc)
         if colIndex!=-1:
             targetCols.remove(gc)
             
     self.lstTargetFields.addItems(targetCols)
    def _on_enum_table_changed(self, index):
        """
        Slot raised when an enumeration table is selected.
        :param index: Index of currently selected item.
        :type index: int
        """
        enum_table = self.cbo_enum_table.currentText()

        self.cbo_primary_col.clear()
        self.cbo_other_col.clear()

        self._enum_col_names = []

        if enum_table:
            self._enum_col_names = table_column_names(enum_table)

            # Remove id column name
            id_col = "id"
            id_idx = getIndex(self._enum_col_names, id_col)
            if id_idx != -1:
                self._enum_col_names.remove(id_col)

            self.cbo_primary_col.addItem("")
            self.cbo_primary_col.addItems(self._enum_col_names)
Пример #16
0
    def loadReportSettings(self,file):
        #Helper for restoring previously saved report settings
        
        #Deserialize report settings 
        rptSerializer = ReportSerializer(file) 
        rptValid, rptConf = rptSerializer.deserialize()
        #Validate if the object is an STDM Report Settings file      
        if rptValid:          
            #Check if the table exists
            tabExists = self._tableExists(rptConf.table)
            #QMessageBox.information(self, "List of tables", str(rptConf.table))
            if tabExists:
                self.showhideProgressDialog(QApplication.translate("ReportBuilder","Restoring Report Settings..."))
                #friendlyTabName = self.tabNames[rptConf.table]
                friendlyTabName = rptConf.table
                
                #Force builder reset even if the loaded report refers to the previously loaded table            
                if rptConf.table == self.tabName:
                    self.tabChanged(friendlyTabName)
                else:                  
                    self.tabName = rptConf.table
                    #QMessageBox.information(self, "table name name", str(self.tabName))
                    #Set focus to report table in the drop down menu
                    setComboCurrentIndexWithItemData(self.comboBox, friendlyTabName)

                #Validate the fields
                validTabFields = table_column_names(rptConf.table)
                validRptFields, invalidRptFields = compareLists(validTabFields, rptConf.fields)
                            
                #Configure supporting controls
                self.loadSettings_activateControls(validRptFields)
                #Set filter statement
                self.txtSqlParser.setText(rptConf.filter)
                
                #Group order container
                gpInfoCollection =[]
                
                #Sort info container
                sortInfoCollection =[]
                
                #Iterate report elements
                for r in rptConf.reportElementCollection:
                    if r.parent != "Groups":
                        #Get corresponding widget and load the settings
                        rptWidg = self.__displayGetStWidget(r.name)
                        if not rptWidg == None:
                            rptWidg.loadSettings(r.dialogSettings)
                            
                        #Set grouping and sorting configuration
                        if r.parent == "Fields":
                            gpInfo = r.uiConfiguration.groupingInfo
                            if gpInfo != None:
                                gpInfo.field = r.name
                                gpInfoCollection.append(gpInfo)
                            fieldSort = r.uiConfiguration.sortInfo
                            
                            if fieldSort.direction != SortDir.Null:
                                fieldSort.field = r.name
                                sortInfoCollection.append(fieldSort) 
                                                           
                #Sort GROUPINFO items using the order attribute then add fields to the report builder controls
                gpInfoCollection.sort(key=lambda g: g.order)
                for g in gpInfoCollection:
                    groupDlg = self.grouping_addFieldByName(g.field)
                    groupDlg.loadSettings(g.dialogSettings) 
                    
                #Order SORTINFO items using the order attribute then add fields to the report builder controls
                sortInfoCollection.sort(key=lambda s: s.order)
                for s in sortInfoCollection:
                    sortItem = self.sorting_getFieldItem(s.field)
                    if sortItem is not None:
                        rowIndex = sortItem.row()
                        dirCombo = self.tbSortFields.cellWidget(rowIndex,1)
                        if s.direction == SortDir.Ascending:
                            setComboCurrentIndexWithText(dirCombo, "Ascending")
                        elif s.direction == SortDir.Descending:
                            setComboCurrentIndexWithText(dirCombo, "Descending")    
                                                                 
                #Show message of invalid fields
                if len(invalidRptFields) > 0:
                    fieldsStr = ",".join(invalidRptFields)
                    msg = QApplication.translate("ReportBuilder"," columns do not exist in the current table definition."
                                                                                 "\nThey will not be included in the report")
                    self.ErrorInfoMessage(fieldsStr + msg)
            else:
                self.showhideProgressDialog("", False)
                msg = QApplication.translate("ReportBuilder"," table or view does not exist in the database")
                self.ErrorInfoMessage(rptConf.table + msg)
        else:
            self.showhideProgressDialog("", False)
            fileName = str(file.section("/",-1))
            msg = QApplication.translate("ReportBuilder"," is not a valid STDM Report Settings file.\n "
                                                                                    "Please validate the source of the file")
            self.ErrorInfoMessage(fileName +msg )
        
        self.showhideProgressDialog("", False)
Пример #17
0
 def loadGeomCols(self,table):
     #Load geometry columns based on the selected table 
     self.geomcols = table_column_names(table,True)
     self.geomClm.clear()
     self.geomClm.addItems(self.geomcols)
Пример #18
0
    def draw_spatial_unit(self, model, clear_existing=True):
        """
        Draw geometry of the given model in the respective local and web views.
        :param model: Source model whose geometry will be drawn.
        :type model: object
        :param clear_existing: Clears any existing features prior to adding the
        new features.
        :type clear_existing: bool
        """
        if model is None:
            msg = QApplication.translate("SpatialPreview",
                                         "Data model is empty, the spatial "
                                         "unit cannot be rendered.")
            QMessageBox.critical(self, QApplication.translate("SpatialPreview",
                                                              "Spatial Unit Preview"),
                                 msg)

            return

        table_name = model.__class__.__name__.replace(' ', '_').lower()
        if not pg_table_exists(table_name):
            msg = QApplication.translate("SpatialPreview",
                                         "The spatial unit data source could "
                                         "not be retrieved, the feature cannot "
                                         "be rendered.")
            QMessageBox.critical(self, QApplication.translate("SpatialPreview",
                                                              "Spatial Unit Preview"),
                                 msg)

            return

        spatial_cols = table_column_names(table_name, True)

        geom, geom_col = None, ""

        for sc in spatial_cols:
            geom = getattr(model, sc)

            #Use the first non-empty geometry value in the collection
            if not geom is None:
                geom_col = sc

        if geom is None:
            msg = QApplication.translate("SpatialPreview",
                                         "The selected spatial unit does not "
                                         "contain a valid geometry.")
            QMessageBox.critical(self, QApplication.translate("SpatialPreview",
                                                              "Spatial Unit Preview"),
                                 msg)

            return

        geom_type, epsg_code = geometryType(table_name, geom_col)

        if self._overlay_layer is None:
            self._create_vector_layer(geom_type, epsg_code)

            #Add layer to map
            QgsMapLayerRegistry.instance().addMapLayer(self._overlay_layer,
                                                       False)
            #Ensure it is always added on top
            QgsProject.instance().layerTreeRoot().insertLayer(0, self._overlay_layer)

        if clear_existing:
            self.delete_local_features()

        feat, extent = self._add_geom_to_map(geom)

        #Add spatial unit to web viewer
        self._web_spatial_loader.add_overlay(model, geom_col)

        #Increase bounding box by 50%, so that layer slightly zoomed out
        extent.scale(1.5)

        #Select feature. Hack for forcing a selection by using inversion
        self._overlay_layer.invertSelection()

        self._iface.mapCanvas().setExtent(extent)
        self._iface.mapCanvas().refresh()
        self.refresh_canvas_layers()

        #Need to force event so that layer is shown
        QCoreApplication.sendEvent(self.local_map, QShowEvent())