Ejemplo n.º 1
0
    def test_field_editability_depends_on_feature(self):
        """
        Test QgsVectorLayerUtils.fieldEditabilityDependsOnFeature
        """
        layer = createLayerWithOnePoint()

        # not joined fields, so answer should be False
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 0))
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 1))

        # joined field
        layer2 = QgsVectorLayer(
            "Point?field=fldtxt2:string&field=fldint:integer", "addfeat",
            "memory")
        join_info = QgsVectorLayerJoinInfo()
        join_info.setJoinLayer(layer2)
        join_info.setJoinFieldName('fldint')
        join_info.setTargetFieldName('fldint')
        join_info.setUsingMemoryCache(True)
        layer.addJoin(join_info)
        layer.updateFields()

        self.assertEqual([f.name() for f in layer.fields()],
                         ['fldtxt', 'fldint', 'addfeat_fldtxt2'])
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 0))
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 1))
        # join layer is not editable => regardless of the feature, the field will always be read-only
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 2))

        # make join editable
        layer.removeJoin(layer2.id())
        join_info.setEditable(True)
        join_info.setUpsertOnEdit(True)
        layer.addJoin(join_info)
        layer.updateFields()
        self.assertEqual([f.name() for f in layer.fields()],
                         ['fldtxt', 'fldint', 'addfeat_fldtxt2'])

        # has upsert on edit => regardless of feature, we can create the join target to make the field editable
        self.assertFalse(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 2))

        layer.removeJoin(layer2.id())
        join_info.setEditable(True)
        join_info.setUpsertOnEdit(False)
        layer.addJoin(join_info)
        layer.updateFields()
        self.assertEqual([f.name() for f in layer.fields()],
                         ['fldtxt', 'fldint', 'addfeat_fldtxt2'])

        # No upsert on edit => depending on feature, we either can edit the field or not, depending on whether
        # the join target feature already exists or not
        self.assertTrue(
            QgsVectorLayerUtils.fieldEditabilityDependsOnFeature(layer, 2))
 def buildJoin(self, originalLyr, originalLyrFieldName, joinnedLyr, joinLyrFieldName, startEdit=False):
     """
     Builds a join bewteen lyr and joinnedLyr.
     :param originalLyr: QgsVectorLayer original layer;
     :param originalLyrFieldName: (str) name of the field;
     :param joinnedLyr: QgsVectorLayer lyr to be joinned to originalLayer;
     :param joinLyrFieldName: (str) name of the join field name (usually primary key of joinnedLyr)
     """
     joinObject = QgsVectorLayerJoinInfo()
     joinObject.setJoinFieldName(joinLyrFieldName)
     joinObject.setTargetFieldName(originalLyrFieldName)
     if startEdit:
         joinnedLyr.startEditing()
     joinObject.setJoinLayer(joinnedLyr)
     # joinObject.setJoinFieldNamesSubset([])
     joinObject.setUpsertOnEdit(True) #set to enable edit on original lyr
     joinObject.setCascadedDelete(True)
     joinObject.setDynamicFormEnabled(True)
     joinObject.setEditable(True)
     joinObject.setUsingMemoryCache(True)
     originalLyr.addJoin(joinObject)
Ejemplo n.º 3
0
 def joinTables(self):
     d, f = self.lyrPair()
     for k, v in d.items():
         target = QgsProject.instance().mapLayer(k)
         layerToJoin = QgsProject.instance().mapLayer(v)
         fieldToJoin = QgsProject.instance()
         symb = QgsVectorLayerJoinInfo()
         symb.setJoinFieldName('id_feature')
         symb.setTargetFieldName('id')
         symb.setJoinLayerId(layerToJoin.id())
         symb.setUsingMemoryCache(True)
         symb.setEditable(True)
         symb.setDynamicFormEnabled(True)
         symb.setUpsertOnEdit(True)
         symb.setPrefix('')
         symb.setJoinFieldNamesSubset([
             'ocultar', 'legenda', 'tamanhotxt', 'justtxt', 'orient_txt',
             'orient_simb', 'offset_txt', 'offset_simb', 'prioridade',
             'offset_txt_x', 'offset_txt_y'
         ])
         symb.setJoinLayer(layerToJoin)
         target.addJoin(symb)
Ejemplo n.º 4
0
 def joinTables(self):
     d, f = self.lyrPair()
     for k, v in d.items():
         target = QgsProject.instance().mapLayer(k)
         layerToJoin = QgsProject.instance().mapLayer(v)
         """  # tests for previous joined layers - under research
         i = QgsProject.instance().mapLayers().values()
         for layer in i:
             fh_lyr = layer
             joinsInfo = fh_lyr.vectorJoins()
             
             if joinsInfo != 0:
                 QMessageBox.critical(iface.mainWindow(), "Error",
                                     "Previously Joins already exists! Please remove joins and try again.")
                 break  # ask for remove previous joins. use removeJoinTables()
             else:
         """
         # target.removeJoin(layerToJoin.id())
         fieldToJoin = QgsProject.instance()
         symb = QgsVectorLayerJoinInfo()
         symb.setJoinFieldName('id_feature')
         symb.setTargetFieldName('id')
         symb.setJoinLayerId(layerToJoin.id())
         symb.setUsingMemoryCache(True)
         symb.setEditable(True)
         symb.setDynamicFormEnabled(True)
         symb.setUpsertOnEdit(True)
         symb.setPrefix('')
         symb.setJoinFieldNamesSubset([
             'ocultar', 'legenda', 'tamanhotxt', 'justtxt', 'orient_txt',
             'orient_simb', 'offset_txt', 'offset_simb', 'prioridade',
             'offset_txt_x', 'offset_txt_y'
         ])
         symb.setJoinLayer(layerToJoin)
         target.addJoin(symb)
         layerToJoin.startEditing()
         target.triggerRepaint()
Ejemplo n.º 5
0
    def testJoinedFieldIsEditableRole(self):
        layer = QgsVectorLayer("Point?field=id_a:integer", "addfeat", "memory")
        layer2 = QgsVectorLayer("Point?field=id_b:integer&field=value_b",
                                "addfeat", "memory")
        QgsProject.instance().addMapLayers([layer, layer2])

        # editable join
        join_info = QgsVectorLayerJoinInfo()
        join_info.setTargetFieldName("id_a")
        join_info.setJoinLayer(layer2)
        join_info.setJoinFieldName("id_b")
        join_info.setPrefix("B_")
        join_info.setEditable(True)
        join_info.setUpsertOnEdit(True)
        layer.addJoin(join_info)

        m = QgsFieldModel()
        m.setLayer(layer)

        self.assertIsNone(
            m.data(m.indexFromName('id_a'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertTrue(
            m.data(m.indexFromName('B_value_b'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertIsNone(
            m.data(m.indexFromName('an expression'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertIsNone(
            m.data(m.indexFromName(None), QgsFieldModel.JoinedFieldIsEditable))
        m.setAllowExpression(True)
        m.setExpression('an expression')
        self.assertIsNone(
            m.data(m.indexFromName('an expression'),
                   QgsFieldModel.JoinedFieldIsEditable))
        m.setAllowEmptyFieldName(True)
        self.assertIsNone(
            m.data(m.indexFromName(None), QgsFieldModel.JoinedFieldIsEditable))

        proxy_m = QgsFieldProxyModel()
        proxy_m.setFilters(QgsFieldProxyModel.AllTypes
                           | QgsFieldProxyModel.HideReadOnly)
        proxy_m.sourceFieldModel().setLayer(layer)
        self.assertEqual(proxy_m.rowCount(), 2)
        self.assertEqual(proxy_m.data(proxy_m.index(0, 0)), 'id_a')
        self.assertEqual(proxy_m.data(proxy_m.index(1, 0)), 'B_value_b')

        # not editable join
        layer3 = QgsVectorLayer("Point?field=id_a:integer", "addfeat",
                                "memory")
        QgsProject.instance().addMapLayers([layer3])
        join_info = QgsVectorLayerJoinInfo()
        join_info.setTargetFieldName("id_a")
        join_info.setJoinLayer(layer2)
        join_info.setJoinFieldName("id_b")
        join_info.setPrefix("B_")
        join_info.setEditable(False)

        layer3.addJoin(join_info)
        m = QgsFieldModel()
        m.setLayer(layer3)

        self.assertIsNone(
            m.data(m.indexFromName('id_a'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertFalse(
            m.data(m.indexFromName('B_value_b'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertIsNone(
            m.data(m.indexFromName('an expression'),
                   QgsFieldModel.JoinedFieldIsEditable))
        self.assertIsNone(
            m.data(m.indexFromName(None), QgsFieldModel.JoinedFieldIsEditable))
        m.setAllowExpression(True)
        m.setExpression('an expression')
        self.assertIsNone(
            m.data(m.indexFromName('an expression'),
                   QgsFieldModel.JoinedFieldIsEditable))
        m.setAllowEmptyFieldName(True)
        self.assertIsNone(
            m.data(m.indexFromName(None), QgsFieldModel.JoinedFieldIsEditable))

        proxy_m = QgsFieldProxyModel()
        proxy_m.sourceFieldModel().setLayer(layer3)
        proxy_m.setFilters(QgsFieldProxyModel.AllTypes
                           | QgsFieldProxyModel.HideReadOnly)
        self.assertEqual(proxy_m.rowCount(), 1)
        self.assertEqual(proxy_m.data(proxy_m.index(0, 0)), 'id_a')