def testQgsSVGFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSVGFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSVGFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSVGFillSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'accommodation_camping.svg'
mValue = os.path.basename(mSymbolLayer.svgFilePath())
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6
mValue = mSymbolLayer.patternWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsCentroidFillSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsCentroidFillSymbolLayerV2'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsCentroidFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsCentroidFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'regular_star'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#55aaff'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#00ff00'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def createSimpleMemorial(self):
tempDoc = QDomDocument()
simple = QFile(self.simpleMemorial)
simple.open(QIODevice.ReadOnly)
loaded = tempDoc.setContent(simple)
simple.close()
element = tempDoc.documentElement()
nodes = element.elementsByTagName("table")
table = nodes.item(0).toElement()
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, u"MEMORIAL DESCRITIVO SINTÉTICO", 7, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, u"VÉRTICE", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "COORDENADAS", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, "LADO", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "AZIMUTES", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, u"DISTÂNCIA", 0, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, "E", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "N", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "PLANO", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "REAL", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "(m)", 0, 0))
table.appendChild(tr)
convergence = float(self.convergenciaEdit.text())
rowCount = self.tableWidget.rowCount()
for i in range(0,rowCount):
lineElement = tempDoc.createElement("tr")
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,0).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,1).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,2).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,3).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,4).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,5).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,6).text(), 0, 0))
table.appendChild(lineElement)
simple = open(self.simpleMemorial, "w", encoding='utf-8')
simple.write(tempDoc.toString())
simple.close()
def createEllipseSymbolLayer(self):
# No way to build it programmatically...
mTestName = 'QgsEllipseSymbolLayer'
mFilePath = QDir.toNativeSeparators(
'%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsEllipseSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
return mSymbolLayer
def testQgsSimpleLineSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsSimpleLineSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleLineSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("LineSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsSimpleLineSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#aa007f"
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.26
mValue = mSymbolLayer.width()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.RoundCap
mValue = mSymbolLayer.penCapStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.MiterJoin
mValue = mSymbolLayer.penJoinStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = True
mValue = mSymbolLayer.useCustomDashPattern()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = [5.0, 2.0]
mValue = mSymbolLayer.customDashVector()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsLinePatternFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsLinePatternFillSymbolLayer"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsLinePatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsLinePatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff55ff"
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.5
mValue = mSymbolLayer.lineWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 4
mValue = mSymbolLayer.distance()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 57
mValue = mSymbolLayer.lineAngle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsMarkerLineSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsMarkerLineSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsMarkerLineSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("LineSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsMarkerLineSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsMarkerLineSymbolLayerV2.CentralPoint
mValue = mSymbolLayer.placement()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"circle"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#000000"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff0000"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsPointPatternFillSymbolLayerSld(self):
"""
Create a new style from a .sld file and match test
"""
# at the moment there is an empty createFromSld implementation
# that return nulls
mTestName = "QgsPointPatternFillSymbolLayer"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsPointPatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsPointPatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"triangle"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffaa00"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff007f"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 5
mValue = mSymbolLayer.subSymbol().symbolLayer(0).angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 3
mValue = mSymbolLayer.subSymbol().symbolLayer(0).size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsCentroidFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsCentroidFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsCentroidFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsCentroidFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsSimpleMarkerSymbolLayerBase.Star
mValue = mSymbolLayer.subSymbol().symbolLayer(0).shape()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = '#55aaff'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = '#00ff00'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).strokeColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = False
mValue = mSymbolLayer.pointOnAllParts()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsEllipseSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsEllipseSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsEllipseSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PointSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsEllipseSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"circle"
mValue = mSymbolLayer.symbolName()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffff7f"
mValue = mSymbolLayer.fillColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#aaaaff"
mValue = mSymbolLayer.outlineColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 7
mValue = mSymbolLayer.symbolWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 5
mValue = mSymbolLayer.symbolHeight()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsFontMarkerSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsFontMarkerSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsFontMarkerSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PointSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsFontMarkerSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"Arial"
mValue = mSymbolLayer.fontFamily()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"M"
mValue = mSymbolLayer.character()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6.23
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 3
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsLinePatternFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsLinePatternFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsLinePatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsLinePatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#ff55ff'
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.5
mValue = mSymbolLayer.lineWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 4
mValue = mSymbolLayer.distance()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 57
mValue = mSymbolLayer.lineAngle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSimpleFillSymbolLayerV2(self):
"""Create a new style from a .sld file and match test.
"""
mTestName = "QgsSimpleFillSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsSimpleFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.SolidPattern
mValue = mSymbolLayer.brushStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffaa7f"
mValue = mSymbolLayer.borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.DotLine
mValue = mSymbolLayer.borderStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 0.26
mValue = mSymbolLayer.borderWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsFontMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsFontMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsFontMarkerSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsFontMarkerSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'Arial'
mValue = mSymbolLayer.fontFamily()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = "M"
mValue = mSymbolLayer.character()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6.23
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 3
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSimpleFillSymbolLayer(self):
"""Create a new style from a .sld file and match test.
"""
mTestName = 'QgsSimpleFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' %
(unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSimpleFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.SolidPattern
mValue = mSymbolLayer.brushStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = '#ffaa7f'
mValue = mSymbolLayer.strokeColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.DotLine
mValue = mSymbolLayer.strokeStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 0.26
mValue = mSymbolLayer.strokeWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def save_dependency_file(self, fetcher_task):
if fetcher_task.reply() is not None:
# Write response to tmp file
tmp_file = tempfile.mktemp()
out_file = QFile(tmp_file)
out_file.open(QIODevice.WriteOnly)
out_file.write(fetcher_task.reply().readAll())
out_file.close()
dependency_base_path = os.path.join(os.path.expanduser('~'), 'Asistente-LADM_COL')
if not os.path.exists(dependency_base_path):
os.makedirs(dependency_base_path)
try:
with zipfile.ZipFile(tmp_file, "r") as zip_ref:
zip_ref.extractall(dependency_base_path)
except zipfile.BadZipFile as e:
self.qgis_utils.message_with_duration_emitted.emit(
QCoreApplication.translate("ReportGenerator", "There was an error with the download. The downloaded file is invalid."),
Qgis.Warning,
0)
except PermissionError as e:
self.qgis_utils.message_with_duration_emitted.emit(
QCoreApplication.translate("ReportGenerator", "Dependencies to generate reports couldn't be installed. Check if it is possible to write into this folder: <a href='file:///{path}'>{path}</a>").format(path=normalize_local_url(os.path.join(dependency_base_path), 'impresion')),
Qgis.Warning,
0)
else:
self.qgis_utils.message_with_duration_emitted.emit(
QCoreApplication.translate("ReportGenerator", "The dependency to generate reports is properly installed! Select plots and click again the button in the toolbar to generate reports."),
Qgis.Info,
0)
try:
os.remove(tmp_file)
except:
pass
self._downloading = False
def uploadImage(self, pathToImage):
img = QFile(pathToImage)
img.open(QIODevice.ReadOnly)
imgPart = QHttpPart()
txt = 'form-data; name="file"; filename="' + os.path.basename(
pathToImage) + '"'
imgPart.setHeader(QNetworkRequest.ContentDispositionHeader, txt)
imgPart.setHeader(QNetworkRequest.ContentTypeHeader, 'image/zip')
imgPart.setBodyDevice(img)
multiPart = QHttpMultiPart(QHttpMultiPart.FormDataType)
multiPart.append(imgPart)
url = self.baseurl + 'projectimage/upload.action?'
response = self.http.request(url, method='POST', body=multiPart)
if response[0]['status'] > 199 and response[0]['status'] < 210:
# if icon upload was successfull, server returns id of the new icon
# in it's database
id = json.loads(response[1])['data']['id']
return id
else:
return False
def table_view_dependencies(table_name, column_name=None):
"""
Find database views that are dependent on the given table and
optionally the column.
:param table_name: Table name
:type table_name: str
:param column_name: Name of the column whose dependent views are to be
extracted.
:type column_name: str
:return: A list of views which are dependent on the given table name and
column respectively.
:rtype: list(str)
"""
views = []
# Load the SQL file depending on whether its table or table/column
if column_name is None:
script_path = PLUGIN_DIR + '/scripts/table_related_views.sql'
else:
script_path = PLUGIN_DIR + '/scripts/table_column_related_views.sql'
script_file = QFile(script_path)
if not script_file.exists():
raise IOError('SQL file for retrieving view dependencies could '
'not be found.')
else:
if not script_file.open(QIODevice.ReadOnly):
raise IOError('Failed to read the SQL file for retrieving view '
'dependencies.')
reader = QTextStream(script_file)
sql = reader.readAll()
if sql:
t = text(sql)
if column_name is None:
result = _execute(t, table_name=table_name)
else:
result = _execute(t,
table_name=table_name,
column_name=column_name)
# Get view names
for r in result:
view_name = r['view_name']
views.append(view_name)
return views
def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' %
(unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def requestFinished(self):
if self.reply.error() != QNetworkReply.NoError:
QApplication.restoreOverrideCursor()
iface.messageBar().pushMessage(
"Lessons could not be installed:\n",
self.reply.errorString(),
QgsMessageBar.WARNING)
self.reply.deleteLater()
return
f = QFile(tempFilenameInTempFolder(os.path.basename(self.url).split(".")[0]))
f.open(QFile.WriteOnly)
f.write(self.reply.readAll())
f.close()
self.reply.deleteLater()
from lessons import installLessonsFromZipFile
installLessonsFromZipFile(f.fileName())
QApplication.restoreOverrideCursor()
iface.messageBar().pushMessage(
"Completed",
"Lessons were correctly installed",
QgsMessageBar.INFO)
def loadProject(self):
f = QFile(self.projectFile)
if not f.open(QIODevice.ReadOnly | QIODevice.Text):
msg = self.tr("Cannot read file %s:\n%s.") % (self.projectFile,
f.errorString())
raise IOError(msg)
doc = QDomDocument()
setOk, errorString, errorLine, errorColumn = doc.setContent(f, True)
if not setOk:
msg = (self.tr("Parse error at line %d, column %d:\n%s") %
(errorLine, errorColumn, errorString))
raise SyntaxError(msg)
f.close()
return doc
def __init__(self, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
self.qgis_utils = qgis_utils
self.check_local_help()
self.tb_changelog.setOpenExternalLinks(True)
if QGIS_LANG == 'en':
file = QFile(":/Asistente-LADM_COL/resources/html/Changelog_en.html")
else:
file = QFile(":/Asistente-LADM_COL/resources/html/Changelog.html")
if not file.open(QIODevice.ReadOnly | QIODevice.Text):
raise Exception(file.errorString())
stream = QTextStream(file)
stream.setCodec("UTF-8")
self.tb_changelog.setHtml(stream.readAll())
def load_template_into_layout(layout: QgsLayout, file_path: str):
"""
Loads a document template into the view and updates the necessary STDM-related composer items.
"""
copy_file = file_path.replace('sdt', 'cpy')
# remove existing copy file
if QFile.exists(copy_file):
copy_template = QFile(copy_file)
copy_template.remove()
orig_template_file = QFile(file_path)
layout.setCustomProperty('variable_template_path', file_path)
# make a copy of the original
orig_template_file.copy(copy_file)
# work with copy
template_file = QFile(copy_file)
if not template_file.open(QIODevice.ReadOnly):
raise IOError(template_file.errorString())
template_doc = QDomDocument()
if template_doc.setContent(template_file):
# First load vector layers for the table definitions in the config
# collection before loading the composition from file.
# table_config_collection = TableConfigurationCollection.create(template_doc)
# Load items into the composition and configure STDM data controls
context = QgsReadWriteContext()
try:
layout.loadFromTemplate(template_doc, context)
except:
pass
LayoutUtils.sync_ids_with_uuids(layout)
template_file.close()
def exportDocument(self, task, fileName, format):
"""
:type task: QUrl
:type fileName: str
:type format: self.ExportFormat
:return: bool
"""
fileOut = QFile(fileName)
if not fileOut.open(QIODevice.WriteOnly | QIODevice.Text):
return False
taskMap = self.__parseTask(task)
text = self.__documentContent(taskMap, format)
streamFileOut = QTextStream(fileOut)
streamFileOut.setCodec("UTF-8")
streamFileOut << text
streamFileOut.flush()
fileOut.close()
return True
def load_aoi_from_file(self):
path, _ = QFileDialog.getOpenFileName(self, "Open GeoJSON AOI file",
QDir.homePath(),
"JSON (*.json);;All Files (*)")
file = QFile(path)
if not file.open(QFile.ReadOnly | QFile.Text):
return
inf = QTextStream(file)
json_txt = inf.readAll()
try:
json_obj = json.loads(json_txt)
except ValueError:
# noinspection PyUnresolvedReferences
self._show_message('GeoJSON from file invalid',
level=Qgis.Warning,
duration=10)
return
json_geom = geometry_from_json(json_obj)
if not json_geom:
# noinspection PyUnresolvedReferences
self._show_message('GeoJSON geometry from file invalid',
level=Qgis.Warning,
duration=10)
return
geom: QgsGeometry = qgsgeometry_from_geojson(json_geom)
self._aoi_box.setToGeometry(geom,
QgsCoordinateReferenceSystem("EPSG:4326"))
self.leAOI.setText(json.dumps(json_geom))
self.zoom_to_aoi()
def parse_xml(self):
"""Parse the xml file. Returns false if there is failure."""
xml_file = QFile(self._xml_path)
if not xml_file.open(QIODevice.ReadOnly):
return False
document = QDomDocument()
if not document.setContent(xml_file):
return False
xml_file.close()
document_element = document.documentElement()
if document_element.tagName() != 'qgis_style':
return False
# Get all the symbols
self._symbols = []
symbols_element = document_element.firstChildElement('symbols')
symbol_element = symbols_element.firstChildElement()
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
while not symbol_element.isNull():
if symbol_element.tagName() == 'symbol':
symbol = QgsSymbolLayerUtils.loadSymbol(
symbol_element, context)
if symbol:
self._symbols.append({
'name':
symbol_element.attribute('name'),
'symbol':
symbol
})
symbol_element = symbol_element.nextSiblingElement()
return True
def upload_files(self, layer, field_index, features):
"""
Upload given features' source files to remote server and return a dict
formatted as changeAttributeValues expects to update 'datos' attribute
to a remote location.
"""
if not QSettings().value(
'Asistente-LADM_COL/sources/document_repository', False, bool):
self.message_with_duration_emitted.emit(
QCoreApplication.translate(
"SourceHandler",
"The source files were not uploaded to the document repository because you have that option unchecked. You can still upload the source files later using the 'Upload Pending Source Files' menu."
), Qgis.Info, 10)
return dict()
# Test if we have Internet connection and a valid service
dlg = self.qgis_utils.get_settings_dialog()
res, msg = dlg.is_source_service_valid()
if not res:
msg['text'] = QCoreApplication.translate(
"SourceHandler",
"No file could be uploaded to the document repository. You can do it later from the 'Upload Pending Source Files' menu. Reason: {}"
).format(msg['text'])
self.message_with_duration_emitted.emit(
msg['text'], Qgis.Info,
20) # The data is still saved, so always show Info msg
return dict()
file_features = [
feature for feature in features if not feature[field_index] == NULL
and os.path.isfile(feature[field_index])
]
total = len(features)
not_found = total - len(file_features)
upload_dialog = UploadProgressDialog(len(file_features), not_found)
upload_dialog.show()
count = 0
upload_errors = 0
new_values = dict()
for feature in file_features:
data_url = feature[field_index]
file_name = os.path.basename(data_url)
nam = QNetworkAccessManager()
#reply.downloadProgress.connect(upload_dialog.update_current_progress)
multiPart = QHttpMultiPart(QHttpMultiPart.FormDataType)
textPart = QHttpPart()
textPart.setHeader(QNetworkRequest.ContentDispositionHeader,
QVariant("form-data; name=\"driver\""))
textPart.setBody(QByteArray().append('Local'))
filePart = QHttpPart()
filePart.setHeader(
QNetworkRequest.ContentDispositionHeader,
QVariant("form-data; name=\"file\"; filename=\"{}\"".format(
file_name)))
file = QFile(data_url)
file.open(QIODevice.ReadOnly)
filePart.setBodyDevice(file)
file.setParent(
multiPart
) # we cannot delete the file now, so delete it with the multiPart
multiPart.append(filePart)
multiPart.append(textPart)
service_url = '/'.join([
QSettings().value(
'Asistente-LADM_COL/sources/service_endpoint',
DEFAULT_ENDPOINT_SOURCE_SERVICE),
SOURCE_SERVICE_UPLOAD_SUFFIX
])
request = QNetworkRequest(QUrl(service_url))
reply = nam.post(request, multiPart)
#reply.uploadProgress.connect(upload_dialog.update_current_progress)
reply.error.connect(self.error_returned)
multiPart.setParent(reply)
# We'll block execution until we get response from the server
loop = QEventLoop()
reply.finished.connect(loop.quit)
loop.exec_()
response = reply.readAll()
data = QTextStream(response, QIODevice.ReadOnly)
content = data.readAll()
if content is None:
self.log.logMessage(
"There was an error uploading file '{}'".format(data_url),
PLUGIN_NAME, Qgis.Critical)
upload_errors += 1
continue
try:
response = json.loads(content)
except json.decoder.JSONDecodeError:
self.log.logMessage(
"Couldn't parse JSON response from server for file '{}'!!!"
.format(data_url), PLUGIN_NAME, Qgis.Critical)
upload_errors += 1
continue
if 'error' in response:
self.log.logMessage(
"STATUS: {}. ERROR: {} MESSAGE: {} FILE: {}".format(
response['status'], response['error'],
response['message'], data_url), PLUGIN_NAME,
Qgis.Critical)
upload_errors += 1
continue
reply.deleteLater()
if 'url' not in response:
self.log.logMessage(
"'url' attribute not found in JSON response for file '{}'!"
.format(data_url), PLUGIN_NAME, Qgis.Critical)
upload_errors += 1
continue
url = self.get_file_url(response['url'])
new_values[feature.id()] = {field_index: url}
count += 1
upload_dialog.update_total_progress(count)
if not_found > 0:
self.message_with_duration_emitted.emit(
QCoreApplication.translate(
"SourceHandler",
"{} out of {} records {} not uploaded to the document repository because {} file path is NULL or it couldn't be found in the local disk!"
).format(
not_found, total,
QCoreApplication.translate("SourceHandler", "was")
if not_found == 1 else QCoreApplication.translate(
"SourceHandler", "were"),
QCoreApplication.translate("SourceHandler", "its")
if not_found == 1 else QCoreApplication.translate(
"SourceHandler", "their")), Qgis.Info, 0)
if len(new_values):
self.message_with_duration_emitted.emit(
QCoreApplication.translate(
"SourceHandler",
"{} out of {} files {} uploaded to the document repository and {} remote location stored in the database!"
).format(
len(new_values), total,
QCoreApplication.translate("SourceHandler", "was")
if len(new_values) == 1 else QCoreApplication.translate(
"SourceHandler", "were"),
QCoreApplication.translate("SourceHandler", "its")
if len(new_values) == 1 else QCoreApplication.translate(
"SourceHandler", "their")), Qgis.Info, 0)
if upload_errors:
self.message_with_duration_emitted.emit(
QCoreApplication.translate(
"SourceHandler",
"{} out of {} files could not be uploaded to the document repository because of upload errors! See log for details."
).format(upload_errors, total), Qgis.Info, 0)
return new_values
def run(self, *args, **kwargs):
"""
:param templatePath: The file path to the user-defined template.
:param entityFieldName: The name of the column for the specified entity which
must exist in the data source view or table.
:param entityFieldValue: The value for filtering the records in the data source
view or table.
:param outputMode: Whether the output composition should be an image or PDF.
:param filePath: The output file where the composition will be written to. Applies
to single mode output generation.
:param dataFields: List containing the field names whose values will be used to name the files.
This is used in multiple mode configuration.
:param fileExtension: The output file format. Used in multiple mode configuration.
:param data_source: Name of the data source table or view whose
row values will be used to name output files if the options has been
specified by the user.
"""
templatePath = args[0]
entityFieldName = args[1]
entityFieldValue = args[2]
outputMode = args[3]
filePath = kwargs.get("filePath", None)
dataFields = kwargs.get("dataFields", [])
fileExtension = kwargs.get("fileExtension", "")
data_source = kwargs.get("data_source", "")
templateFile = QFile(templatePath)
if not templateFile.open(QIODevice.ReadOnly):
return False, QApplication.translate("DocumentGenerator",
"Cannot read template file.")
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
composerDS = ComposerDataSource.create(templateDoc)
spatialFieldsConfig = SpatialFieldsConfiguration.create(templateDoc)
composerDS.setSpatialFieldsConfig(spatialFieldsConfig)
#Check if data source exists and return if it doesn't
if not self.data_source_exists(composerDS):
msg = QApplication.translate("DocumentGenerator",
"'{0}' data source does not exist in the database."
"\nPlease contact your database "
"administrator.".format(composerDS.name()))
return False, msg
#Set file name value formatter
self._file_name_value_formatter = EntityValueFormatter(
name=data_source
)
#Register field names to be used for file naming
self._file_name_value_formatter.register_columns(dataFields)
#TODO: Need to automatically register custom configuration collections
#Photo config collection
ph_config_collection = PhotoConfigurationCollection.create(templateDoc)
#Table configuration collection
table_config_collection = TableConfigurationCollection.create(templateDoc)
#Create chart configuration collection object
chart_config_collection = ChartConfigurationCollection.create(templateDoc)
# Create QR code configuration collection object
qrc_config_collection = QRCodeConfigurationCollection.create(templateDoc)
#Load the layers required by the table composer items
self._table_mem_layers = load_table_layers(table_config_collection)
entityFieldName = self.format_entity_field_name(composerDS.name(), data_source)
#Execute query
dsTable,records = self._exec_query(composerDS.name(), entityFieldName, entityFieldValue)
if records is None or len(records) == 0:
return False, QApplication.translate("DocumentGenerator",
"No matching records in the database")
"""
Iterate through records where a single file output will be generated for each matching record.
"""
for rec in records:
composition = QgsPrintLayout(self._map_settings)
composition.loadFromTemplate(templateDoc)
ref_layer = None
#Set value of composer items based on the corresponding db values
for composerId in composerDS.dataFieldMappings().reverse:
#Use composer item id since the uuid is stripped off
composerItem = composition.getComposerItemById(composerId)
if not composerItem is None:
fieldName = composerDS.dataFieldName(composerId)
fieldValue = getattr(rec,fieldName)
self._composeritem_value_handler(composerItem, fieldValue)
# Extract photo information
self._extract_photo_info(composition, ph_config_collection, rec)
# Set table item values based on configuration information
self._set_table_data(composition, table_config_collection, rec)
# Refresh non-custom map composer items
self._refresh_composer_maps(composition,
list(spatialFieldsConfig.spatialFieldsMapping().keys()))
# Set use fixed scale to false i.e. relative zoom
use_fixed_scale = False
# Create memory layers for spatial features and add them to the map
for mapId,spfmList in spatialFieldsConfig.spatialFieldsMapping().items():
map_item = composition.getComposerItemById(mapId)
if not map_item is None:
# Clear any previous map memory layer
# self.clear_temporary_map_layers()
for spfm in spfmList:
#Use the value of the label field to name the layer
lbl_field = spfm.labelField()
spatial_field = spfm.spatialField()
if not spatial_field:
continue
if lbl_field:
if hasattr(rec, spfm.labelField()):
layerName = getattr(rec, spfm.labelField())
else:
layerName = self._random_feature_layer_name(spatial_field)
else:
layerName = self._random_feature_layer_name(spatial_field)
#Extract the geometry using geoalchemy spatial capabilities
geom_value = getattr(rec, spatial_field)
if geom_value is None:
continue
geom_func = geom_value.ST_AsText()
geomWKT = self._dbSession.scalar(geom_func)
#Get geometry type
geom_type, srid = geometryType(composerDS.name(),
spatial_field)
#Create reference layer with feature
ref_layer = self._build_vector_layer(layerName, geom_type, srid)
if ref_layer is None or not ref_layer.isValid():
continue
# Add feature
bbox = self._add_feature_to_layer(ref_layer, geomWKT)
zoom_type = spfm.zoom_type
# Only scale the extents if zoom type is relative
if zoom_type == 'RELATIVE':
bbox.scale(spfm.zoomLevel())
#Workaround for zooming to single point extent
if ref_layer.wkbType() == QgsWkbTypes.Point:
canvas_extent = self._iface.mapCanvas().fullExtent()
cnt_pnt = bbox.center()
canvas_extent.scale(1.0/32, cnt_pnt)
bbox = canvas_extent
#Style layer based on the spatial field mapping symbol layer
symbol_layer = spfm.symbolLayer()
if not symbol_layer is None:
ref_layer.rendererV2().symbols()[0].changeSymbolLayer(0,spfm.symbolLayer())
'''
Add layer to map and ensure its always added at the top
'''
self.map_registry.addMapLayer(ref_layer)
self._iface.mapCanvas().setExtent(bbox)
# Set scale if type is FIXED
if zoom_type == 'FIXED':
self._iface.mapCanvas().zoomScale(spfm.zoomLevel())
use_fixed_scale = True
self._iface.mapCanvas().refresh()
# Add layer to map memory layer list
self._map_memory_layers.append(ref_layer.id())
self._hide_layer(ref_layer)
'''
Use root layer tree to get the correct ordering of layers
in the legend
'''
self._refresh_map_item(map_item, use_fixed_scale)
# Extract chart information and generate chart
self._generate_charts(composition, chart_config_collection, rec)
# Extract QR code information in order to generate QR codes
self._generate_qr_codes(composition, qrc_config_collection,rec)
#Build output path and generate composition
if not filePath is None and len(dataFields) == 0:
self._write_output(composition, outputMode, filePath)
elif filePath is None and len(dataFields) > 0:
entityFieldName = 'id'
docFileName = self._build_file_name(data_source, entityFieldName,
entityFieldValue, dataFields, fileExtension)
# Replace unsupported characters in Windows file naming
docFileName = docFileName.replace('/', '_').replace \
('\\', '_').replace(':', '_').strip('*?"<>|')
if not docFileName:
return (False, QApplication.translate("DocumentGenerator",
"File name could not be generated from the data fields."))
outputDir = self._composer_output_path()
if outputDir is None:
return (False, QApplication.translate("DocumentGenerator",
"System could not read the location of the output directory in the registry."))
qDir = QDir()
if not qDir.exists(outputDir):
return (False, QApplication.translate("DocumentGenerator",
"Output directory does not exist"))
absDocPath = "{0}/{1}".format(outputDir, docFileName)
self._write_output(composition, outputMode, absDocPath)
return True, "Success"
return False, "Document composition could not be generated"
class FileDownloader():
"""The blueprint for downloading file from url."""
def __init__(self, url, output_path, progress_dialog=None):
"""Constructor of the class.
.. versionchanged:: 3.3 removed manager parameter.
:param url: URL of file.
:type url: str
:param output_path: Output path.
:type output_path: str
:param progress_dialog: Progress dialog widget.
:type progress_dialog: QWidget
"""
# noinspection PyArgumentList
self.manager = QgsNetworkAccessManager.instance()
self.url = QUrl(url)
self.output_path = output_path
self.progress_dialog = progress_dialog
if self.progress_dialog:
self.prefix_text = self.progress_dialog.labelText()
self.output_file = None
self.reply = None
self.downloaded_file_buffer = None
self.finished_flag = False
def download(self):
"""Downloading the file.
:returns: True if success, otherwise returns a tuple with format like
this (QNetworkReply.NetworkError, error_message)
:raises: IOError - when cannot create output_path
"""
# Prepare output path
self.output_file = QFile(self.output_path)
if not self.output_file.open(QFile.WriteOnly):
raise IOError(self.output_file.errorString())
# Prepare downloaded buffer
self.downloaded_file_buffer = QByteArray()
# Request the url
request = QNetworkRequest(self.url)
self.reply = self.manager.get(request)
self.reply.readyRead.connect(self.get_buffer)
self.reply.finished.connect(self.write_data)
self.manager.requestTimedOut.connect(self.request_timeout)
if self.progress_dialog:
# progress bar
def progress_event(received, total):
"""Update progress.
:param received: Data received so far.
:type received: int
:param total: Total expected data.
:type total: int
"""
# noinspection PyArgumentList
QgsApplication.processEvents()
self.progress_dialog.adjustSize()
human_received = humanize_file_size(received)
human_total = humanize_file_size(total)
label_text = tr(
"%s : %s of %s" %
(self.prefix_text, human_received, human_total))
self.progress_dialog.setLabelText(label_text)
self.progress_dialog.setMaximum(total)
self.progress_dialog.setValue(received)
# cancel
def cancel_action():
"""Cancel download."""
self.reply.abort()
self.reply.deleteLater()
self.reply.downloadProgress.connect(progress_event)
self.progress_dialog.canceled.connect(cancel_action)
# Wait until finished
# On Windows 32bit AND QGIS 2.2, self.reply.isFinished() always
# returns False even after finished slot is called. So, that's why we
# are adding self.finished_flag (see #864)
while not self.reply.isFinished() and not self.finished_flag:
# noinspection PyArgumentList
QgsApplication.processEvents()
result = self.reply.error()
try:
http_code = int(
self.reply.attribute(QNetworkRequest.HttpStatusCodeAttribute))
except TypeError:
# If the user cancels the request, the HTTP response will be None.
http_code = None
self.reply.abort()
self.reply.deleteLater()
if result == QNetworkReply.NoError:
return True, None
elif result == QNetworkReply.UnknownNetworkError:
return False, tr(
'The network is unreachable. Please check your internet '
'connection.')
elif http_code == 408:
msg = tr('Sorry, the server aborted your request. '
'Please try a smaller area.')
LOGGER.debug(msg)
return False, msg
elif http_code == 509:
msg = tr(
'Sorry, the server is currently busy with another request. '
'Please try again in a few minutes.')
LOGGER.debug(msg)
return False, msg
elif result == QNetworkReply.ProtocolUnknownError or \
result == QNetworkReply.HostNotFoundError:
# See http://doc.qt.io/qt-5/qurl-obsolete.html#encodedHost
encoded_host = self.url.toAce(self.url.host())
LOGGER.exception('Host not found : %s' % encoded_host)
return False, tr(
'Sorry, the server is unreachable. Please try again later.')
elif result == QNetworkReply.ContentNotFoundError:
LOGGER.exception('Path not found : %s' % self.url.path())
return False, tr('Sorry, the layer was not found on the server.')
else:
return result, self.reply.errorString()
def get_buffer(self):
"""Get buffer from self.reply and store it to our buffer container."""
buffer_size = self.reply.size()
data = self.reply.read(buffer_size)
self.downloaded_file_buffer.append(data)
def write_data(self):
"""Write data to a file."""
self.output_file.write(self.downloaded_file_buffer)
self.output_file.close()
self.finished_flag = True
def request_timeout(self):
"""The request timed out."""
if self.progress_dialog:
self.progress_dialog.hide()
def foreign_key_parent_tables(table_name, search_parent=True, filter_exp=None):
"""
Function that searches for foreign key references in the specified table.
:param table_name: Name of the database table.
:type table_name: str
:param search_parent: Select True if table_name is the child and
parent tables are to be retrieved, else child tables will be
returned.
:type search_parent: bool
:param filter_exp: A regex expression to filter related table names.
:type filter_exp: QRegExp
:return: A list of tuples containing the local column name, foreign table
name, corresponding foreign column name and constraint name.
:rtype: list
"""
# Check if the view for listing foreign key references exists
fk_ref_view = pg_table_exists("foreign_key_references")
# Create if it does not exist
if not fk_ref_view:
script_path = PLUGIN_DIR + "/scripts/foreign_key_references.sql"
script_file = QFile(script_path)
if script_file.exists():
if not script_file.open(QIODevice.ReadOnly):
return None
reader = QTextStream(script_file)
sql = reader.readAll()
if sql:
t = text(sql)
_execute(t)
else:
return None
if search_parent:
ref_table = "foreign_table_name"
search_table = "table_name"
else:
ref_table = "table_name"
search_table = "foreign_table_name"
# Fetch foreign key references
sql = "SELECT column_name,{0},foreign_column_name, constraint_name FROM " \
"foreign_key_references where {1} =:tb_name".format(ref_table,
search_table)
t = text(sql)
result = _execute(t, tb_name=table_name)
fk_refs = []
for r in result:
rel_table = r[ref_table]
fk_ref = r["column_name"], rel_table, \
r["foreign_column_name"], r["constraint_name"]
if not filter_exp is None:
if filter_exp.indexIn(rel_table) >= 0:
fk_refs.append(fk_ref)
continue
fk_refs.append(fk_ref)
return fk_refs
def createSimpleMemorial(self):
tempDoc = QDomDocument()
simple = QFile(self.simpleMemorial)
simple.open(QIODevice.ReadOnly)
loaded = tempDoc.setContent(simple)
simple.close()
element = tempDoc.documentElement()
nodes = element.elementsByTagName("table")
table = nodes.item(0).toElement()
tr = tempDoc.createElement("tr")
tr.appendChild(
self.createCellElement(tempDoc, u"MEMORIAL DESCRITIVO SINTÉTICO",
7, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, u"VÉRTICE", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "COORDENADAS", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, "LADO", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "AZIMUTES", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, u"DISTÂNCIA", 0, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, "E", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "N", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "PLANO", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "REAL", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "(m)", 0, 0))
table.appendChild(tr)
convergence = float(self.convergenciaEdit.text())
rowCount = self.tableWidget.rowCount()
for i in range(0, rowCount):
lineElement = tempDoc.createElement("tr")
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 0).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 1).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 2).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 3).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 4).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 5).text(), 0,
0))
lineElement.appendChild(
self.createCellElement(tempDoc,
self.tableWidget.item(i, 6).text(), 0,
0))
table.appendChild(lineElement)
simple = open(self.simpleMemorial, "w", encoding='utf-8')
simple.write(tempDoc.toString())
simple.close()
def _download_file(self, url, out_path):
reply = self.__sync_request(url)
local_file = QFile(out_path)
local_file.open(QIODevice.WriteOnly)
local_file.write(reply)
local_file.close()
class QgsPluginInstallerInstallingDialog(
QDialog, Ui_QgsPluginInstallerInstallingDialogBase):
# ----------------------------------------- #
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
authcfg = repositories.all()[plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, basestring):
if not QgsAuthManager.instance().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(
authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def exec_(self):
if self.request is None:
return QDialog.Rejected
QDialog.exec_(self)
# ----------------------------------------- #
def result(self):
return self.mResult
# ----------------------------------------- #
def stateChanged(self, state):
messages = [
self.tr("Installing..."),
self.tr("Resolving host name..."),
self.tr("Connecting..."),
self.tr("Host connected. Sending request..."),
self.tr("Downloading data..."),
self.tr("Idle"),
self.tr("Closing connection..."),
self.tr("Error")
]
self.labelState.setText(messages[state])
# ----------------------------------------- #
def readProgress(self, done, total):
if total > 0:
self.progressBar.setMaximum(total)
self.progressBar.setValue(done)
# ----------------------------------------- #
def requestFinished(self):
reply = self.sender()
self.buttonBox.setEnabled(False)
if reply.error() != QNetworkReply.NoError:
self.mResult = reply.errorString()
if reply.error() == QNetworkReply.OperationCanceledError:
self.mResult += "<br/><br/>" + QCoreApplication.translate(
"QgsPluginInstaller",
"If you haven't cancelled the download manually, it might be caused by a timeout. In this case consider increasing the connection timeout value in QGIS options."
)
self.reject()
reply.deleteLater()
return
self.file.open(QFile.WriteOnly)
self.file.write(reply.readAll())
self.file.close()
self.stateChanged(0)
reply.deleteLater()
pluginDir = qgis.utils.home_plugin_path
tmpPath = self.file.fileName()
# make sure that the parent directory exists
if not QDir(pluginDir).exists():
QDir().mkpath(pluginDir)
# if the target directory already exists as a link, remove the link without resolving:
QFile(pluginDir + unicode(QDir.separator()) +
self.plugin["id"]).remove()
try:
unzip(
unicode(tmpPath), unicode(pluginDir)
) # test extract. If fails, then exception will be raised and no removing occurs
# removing old plugin files if exist
removeDir(QDir.cleanPath(
pluginDir + "/" +
self.plugin["id"])) # remove old plugin if exists
unzip(unicode(tmpPath), unicode(pluginDir)) # final extract.
except:
self.mResult = self.tr(
"Failed to unzip the plugin package. Probably it's broken or missing from the repository. You may also want to make sure that you have write permission to the plugin directory:"
) + "\n" + pluginDir
self.reject()
return
try:
# cleaning: removing the temporary zip file
QFile(tmpPath).remove()
except:
pass
self.close()
# ----------------------------------------- #
def abort(self):
if self.reply.isRunning():
self.reply.finished.disconnect()
self.reply.abort()
del self.reply
self.mResult = self.tr("Aborted by user")
self.reject()
def read_cached_dfd_qlr(self):
#return file(unicode(self.cached_kf_qlr_filename)).read()
f = QFile(self.cached_dfd_qlr_filename)
f.open(QIODevice.ReadOnly)
return f.readAll()
def sendOutputFile(self, handler):
formatDict = WFSFormats[self.format]
# read the GML
outputLayer = QgsVectorLayer(
os.path.join(self.tempdir, '%s.gml' % self.filename),
'qgis_server_wfs_features', 'ogr')
if outputLayer.isValid():
try:
# create save options
options = QgsVectorFileWriter.SaveVectorOptions()
# driver name
options.driverName = formatDict['ogrProvider']
# file encoding
options.fileEncoding = 'utf-8'
# coordinate transformation
if formatDict['forceCRS']:
options.ct = QgsCoordinateTransform(
outputLayer.crs(),
QgsCoordinateReferenceSystem(formatDict['forceCRS']),
QgsProject.instance())
# datasource options
if formatDict['ogrDatasourceOptions']:
options.datasourceOptions = formatDict[
'ogrDatasourceOptions']
# write file
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
outputLayer,
os.path.join(
self.tempdir,
'%s.%s' % (self.filename, formatDict['filenameExt'])),
options)
if write_result != QgsVectorFileWriter.NoError:
handler.appendBody(b'')
QgsMessageLog.logMessage(error_message,
"wfsOutputExtension",
Qgis.Critical)
return False
except Exception as e:
handler.appendBody(b'')
QgsMessageLog.logMessage(str(e), "wfsOutputExtension",
Qgis.Critical)
return False
if formatDict['zip']:
# compress files
import zipfile
try:
import zlib
compression = zipfile.ZIP_DEFLATED
except:
compression = zipfile.ZIP_STORED
# create the zip file
with zipfile.ZipFile(
os.path.join(self.tempdir, '%s.zip' % self.filename),
'w') as zf:
# add all files
zf.write(os.path.join(
self.tempdir,
'%s.%s' % (self.filename, formatDict['filenameExt'])),
compress_type=compression,
arcname='%s.%s' %
(self.typename, formatDict['filenameExt']))
for e in formatDict['extToZip']:
if os.path.exists(
os.path.join(self.tempdir,
'%s.%s' % (self.filename, e))):
zf.write(os.path.join(self.tempdir, '%s.%s' %
(self.filename, e)),
compress_type=compression,
arcname='%s.%s' % (self.typename, e))
zf.close()
f = QFile(os.path.join(self.tempdir, '%s.zip' % self.filename))
if (f.open(QFile.ReadOnly)):
ba = f.readAll()
handler.appendBody(ba)
return True
else:
# return the file created without zip
f = QFile(
os.path.join(
self.tempdir,
'%s.%s' % (self.filename, formatDict['filenameExt'])))
if (f.open(QFile.ReadOnly)):
ba = f.readAll()
handler.appendBody(ba)
return True
handler.appendBody(b'')
QgsMessageLog.logMessage('Error no output file', "wfsOutputExtension",
Qgis.Critical)
return False
class InstanceUUIDExtractor():
"""
Class constructor
"""
def __init__(self, path):
"""
Initatlize class variables
"""
self.file_path = path
self.file = None
self.new_list = []
self.doc = QDomDocument()
self.node = QDomNode()
def set_file_path(self, path):
"""
Update the path based on the new file being read
:param path:
:return:
"""
self.file_path = path
def unset_path(self):
"""Clear the current document path"""
self.file_path = None
def set_document(self):
"""
:return:
"""
self.file = QFile(self.file_path)
if self.file.open(QIODevice.ReadOnly):
self.doc.setContent(self.file)
self.file.close()
def update_document(self):
'''Update the current instance by clearing the document in the cache '''
self.doc.clear()
self.set_document()
def on_file_passed(self):
"""
Pass the raw file to an xml document object and format the its filename to GeoODK standards
:return:
"""
try:
self.set_document()
self.read_uuid_element()
self.doc.clear()
self.file.close()
self.rename_file()
except:
pass
def read_uuid_element(self):
"""
get the uuid element and text from the xml document from the mobile divice
"""
node = self.doc.elementsByTagName("meta")
for i in range(node.count()):
node = node.item(i).firstChild().toElement()
self.node = node.text()
return self.node
def document_entities(self, profile):
"""
Get entities in the document
:return:
"""
self.set_document()
node_list = []
nodes = self.doc.elementsByTagName(profile)
node = nodes.item(0).childNodes()
if node:
for j in range(node.count()):
node_val = node.item(j)
node_list.append(node_val.nodeName())
return node_list
def profile_entity_nodes(self, profile):
'''
Fetch and return QDomNodeList for entities of a
profile
:rtype: QDomNodeList
'''
self.set_document()
nodes = self.doc.elementsByTagName(profile)
return nodes.item(0).childNodes()
def document_entities_with_data(self, profile, selected_entities):
"""
Get entities in the dom document matching user
selected entities
:rtype: OrderedDict
"""
instance_data = OrderedDict()
self.set_document()
nodes = self.doc.elementsByTagName(profile)
entity_nodes = nodes.item(0).childNodes()
for attrs in range(entity_nodes.count()):
if entity_nodes.item(attrs).nodeName() in selected_entities:
name_entity = entity_nodes.item(attrs).nodeName()
attr_nodes = self.doc.elementsByTagName(name_entity)
instance_data[attr_nodes] = name_entity
return instance_data
def attribute_data_from_nodelist(self, args_list):
"""
process nodelist data before Importing attribute data into db
"""
repeat_instance_data = OrderedDict()
attribute_data = OrderedDict()
for attr_nodes, entity in args_list.items():
'''The assuption is that there are repeated entities from mobile sub forms. handle them separately'''
if attr_nodes.count() > 1:
for i in range(attr_nodes.count()):
attrib_node = attr_nodes.at(i).childNodes()
attr_list = OrderedDict()
for j in range(attrib_node.count()):
field_name = attrib_node.at(j).nodeName()
field_value = attrib_node.at(j).toElement().text()
attr_list[field_name] = field_value
repeat_instance_data['{}'.format(i) + entity] = attr_list
else:
'''Entities must appear onces in the form'''
node_list_var = OrderedDict()
attr_node = attr_nodes.at(0).childNodes()
for j in range(attr_node.count()):
field_name = attr_node.at(j).nodeName()
field_value = attr_node.at(j).toElement().text()
node_list_var[field_name] = field_value
attribute_data[entity] = node_list_var
return attribute_data, repeat_instance_data
def read_attribute_data_from_node(self, node, entity_name):
"""Read attribute data from a node item"""
node_list_var = OrderedDict()
attributes = OrderedDict()
attr_node = node.at(0).childNodes()
for j in range(attr_node.count()):
field_name = attr_node.at(j).nodeName()
field_value = attr_node.at(j).toElement().text()
node_list_var[field_name] = field_value
attributes[entity_name] = node_list_var
return attributes
def str_definition(self, instance=None):
"""
Check if the instance file has entry social tenure
:return:
"""
if instance:
self.set_file_path(instance)
self.set_document()
attributes = {}
nodes = self.doc.elementsByTagName('social_tenure')
entity_nodes = nodes.item(0).childNodes()
if entity_nodes:
for j in range(entity_nodes.count()):
node_val = entity_nodes.item(j).toElement()
attributes[node_val.nodeName()] = node_val.text().rstrip()
return attributes
def has_str_captured_in_instance(self, instance):
"""
Bool if the str inclusion is required based on whether is captured or not
:return:
"""
count = len(self.str_definition(instance))
return True if count > 1 else False
def entity_atrributes(self):
"""
Get collected data from the entity in the document
:return:
"""
pass
def uuid_element(self):
"""
Format the guuid from the file
:return:
"""
return self.node.replace(":", "")
def rename_file(self):
"""
Remane the existing instance file with Guuid from the mobile divice to conform with GeoODk naming
convention
:return:
"""
if isinstance(self.file, QFile):
dir_n, file_n = os.path.split(self.file_path)
os.chdir(dir_n)
if not file_n.startswith(UUID):
new_file_name = self.uuid_element() + ".xml"
isrenamed = self.file.setFileName(new_file_name)
os.rename(file_n, new_file_name)
self.new_list.append(new_file_name)
return isrenamed
else:
self.new_list.append(self.file.fileName())
self.file.close()
else:
return
def file_list(self):
"""
check through the list of document to ensure they are complete file path
"""
complete_file = []
for fi in self.new_list:
if os.path.isfile(fi):
complete_file.append(fi)
else:
continue
return complete_file
def close_document(self):
'''Close all the open documents and unset current paths'''
self.file_path = None
self.doc.clear()
self.new_list = None
def read_local_qlr(self):
f = QFile(self.local_qlr_filename)
f.open(QIODevice.ReadOnly)
return f.readAll()
class MultipartFile(QFile):
"""Wrapper class to support reading a file in chunks and post each part separately."""
def __init__(self, filename):
super().__init__(filename)
self._file = QFile(filename)
self._bytes_left = 0
self._file.readyRead.connect(self.on_readyRead)
self._file.aboutToClose.connect(self.on_aboutToClose)
self._file.bytesWritten.connect(self.on_bytesWritten)
self._file.channelBytesWritten.connect(self.on_channelBytesWritten)
self._file.channelReadyRead.connect(self.on_channelReadyRead)
self._file.readChannelFinished.connect(self.on_readChannelFinished)
def set_part_size(self, size):
self._bytes_left = size
self._original_size = size
def commitTransaction(self):
QgsMessageLog.logMessage('commitTransaction')
return self._file.commitTransaction()
def currentReadChannel(self):
QgsMessageLog.logMessage('currentReadChannel')
return self._file.currentReadChannel()
def currentWriteChannel(self):
QgsMessageLog.logMessage('currentWriteChannel')
return self._file.currentWriteChannel()
def errorString(self):
QgsMessageLog.logMessage('errorString')
return self._file.errorString()
def getChar(self):
if self._bytes_left > 0:
QgsMessageLog.logMessage('getChar')
self._bytes_left = self._bytes_left - 1
return self._file.getChar()
else:
QgsMessageLog.logMessage('getChar(no bytes left)')
return None
def isOpen(self):
QgsMessageLog.logMessage('isOpen')
return self._file.isOpen()
def isReadable(self):
QgsMessageLog.logMessage('isReadable')
return self._file.isReadable()
def isTextModeEnabled(self):
QgsMessageLog.logMessage('isTextModeEnabled')
return self._file.isTextModeEnabled()
def isTransactionStarted(self):
QgsMessageLog.logMessage('isTransactionStarted')
return self._file.isTransactionStarted()
def isWritable(self):
QgsMessageLog.logMessage('isWritable')
return self._file.isWritable()
def openMode(self):
QgsMessageLog.logMessage('openMode')
return self._file.openMode()
def peek(self, maxlen):
QgsMessageLog.logMessage('peek {0} {1}'.format(maxlen, self._bytes_left))
if maxlen > self._bytes_left:
maxlen = self._bytes_left
return self._file.peek(maxlen)
def read(self, max_size):
QgsMessageLog.logMessage('read {0}'.format(max_size))
return self._file.read(max_size)
def readAll(self):
QgsMessageLog.logMessage('readAll')
data = self._file.read(self._bytes_left)
self._bytes_left = self._bytes_left - len(data)
return data
def readChannelCount(self):
QgsMessageLog.logMessage('readChannelCount')
return self._file.readChannelCount()
def readLine(self):
QgsMessageLog.logMessage('readLine')
return None
def rollbackTransaction(self):
QgsMessageLog.logMessage('rollbackTransaction')
return self._file.rollbackTransaction()
def setCurrentReadChannel(self, channel):
QgsMessageLog.logMessage('setCurrentReadChannel {0}'.format(channel))
return self._file.setCurrentReadChannel(channel)
def setErrorString(self, errorString):
QgsMessageLog.logMessage('setErrorString {0}'.format(errorString))
return self._file.setErrorString(errorString)
def setOpenMode(self, mode):
QgsMessageLog.logMessage('setOpenMode {0}'.format(mode))
return self._file.setOpenMode(mode)
def setTextModeEnabled(self, enabled):
QgsMessageLog.logMessage('setTextModeEnabled {0}'.format(enabled))
return self._file.setTextModeenabled(enabled)
def skip(self, maxSize):
QgsMessageLog.logMessage('skip {0} {1}'.format(maxSize, self._bytes_left))
if maxSize > self._bytes_left:
maxSize = self._bytes_left
return self._file.skip(maxSize)
def startTransaction(self):
QgsMessageLog.logMessage('startTransaction')
return self._file.startTransaction()
def ungetChar(self, c):
QgsMessageLog.logMessage('ungetChar {0}'.format(c))
return None
def writeChannelCount(self):
QgsMessageLog.logMessage('writeChannelCount')
return self._file.writeChannelCount()
def atEnd(self):
QgsMessageLog.logMessage('atEnd')
if self._bytes_left == 0:
return True
else:
return self._file.atEnd()
def bytesAvailable(self):
QgsMessageLog.logMessage('bytesAvailable')
real_bytes_available = self._file.bytesAvailable()
if real_bytes_available > self._bytes_left:
return self._bytes_left
else:
return real_bytes_available
def bytesToWrite(self):
QgsMessageLog.logMessage('bytesToWrite')
return self._file.bytesToWrite()
def canReadLine(self):
QgsMessageLog.logMessage('canReadLine')
return self._file.canReadLine()
def close(self):
QgsMessageLog.logMessage('close')
return self._file.close()
def isSequential(self):
QgsMessageLog.logMessage('isSequential')
return self._file.isSequential()
def open(self, mode):
QgsMessageLog.logMessage('open')
return self._file.open(mode)
def pos(self):
QgsMessageLog.logMessage('pos')
return self._original_size - self._bytes_left
def readData(self, max_size):
if max_size > self._bytes_left:
max_size = self._bytes_left
self._bytes_left = self._bytes_left - max_size
if self._bytes_left == 0:
self.readChannelFinished.emit()
QgsMessageLog.logMessage('readData {0}'.format(max_size))
return self._file.readData(max_size)
def reset(self):
QgsMessageLog.logMessage('readData')
return True
def seek(self, pos):
QgsMessageLog.logMessage('seek {0}'.format(pos))
return True
def size(self):
file_size = self._file.size()
if file_size < self._bytes_left:
QgsMessageLog.logMessage('size(file_size) {0}'.format(file_size))
return file_size
else:
QgsMessageLog.logMessage('size(bytes_left) {0}'.format(self._bytes_left))
return self._bytes_left
def waitForReadyRead(self, msecs):
QgsMessageLog.logMessage('waitForReadyRead {0}'.format(msecs))
return self._file.waitForReadyRead(msecs)
def on_aboutToClose(self):
QgsMessageLog.logMessage('on_aboutToClose')
self.aboutToClose.emit()
def on_bytesWritten(self, bytes_written):
QgsMessageLog.logMessage('on_bytesWritten {0}'.format(bytes_written))
self.bytesWritten.emit(bytes_written)
def on_channelBytesWritten(self, channel, bytes_written):
QgsMessageLog.logMessage('on_channelBytesWritten {0} {1}'.format(channel, bytes_written))
self.channelBytesWritten.emit(channel, bytes_written)
def on_channelReadyRead(self, channel):
QgsMessageLog.logMessage('on_channelReadyRead {0}'.format(channel))
if self._bytes_left > 0:
self.channelReadyRead.emit(channel)
def on_readChannelFinished(self):
QgsMessageLog.logMessage('on_readChannelFinished')
self.readChannelFinished.emit()
def on_readyRead(self):
QgsMessageLog.logMessage('on_readyRead')
if self._bytes_left > 0:
self.readyRead.emit()
def flush(self):
QgsMessageLog.logMessage('flush')
return self._file.flush()
def fileName(self):
QgsMessageLog.logMessage('filename')
return self._file.fileName()
def exists(self):
QgsMessageLog.logMessage('exists')
return self._file.exists()
def decodeName(self, localFileName):
QgsMessageLog.logMessage('decodeName {0}'.format(localFileName))
return self._file.decodeName(localFileName)
class FileDownloader():
"""The blueprint for downloading file from url."""
def __init__(self, url, output_path, progress_dialog=None):
"""Constructor of the class.
.. versionchanged:: 3.3 removed manager parameter.
:param url: URL of file.
:type url: str
:param output_path: Output path.
:type output_path: str
:param progress_dialog: Progress dialog widget.
:type progress_dialog: QWidget
"""
# noinspection PyArgumentList
self.manager = QgsNetworkAccessManager.instance()
self.url = QUrl(url)
self.output_path = output_path
self.progress_dialog = progress_dialog
if self.progress_dialog:
self.prefix_text = self.progress_dialog.labelText()
self.output_file = None
self.reply = None
self.downloaded_file_buffer = None
self.finished_flag = False
def download(self):
"""Downloading the file.
:returns: True if success, otherwise returns a tuple with format like
this (QNetworkReply.NetworkError, error_message)
:raises: IOError - when cannot create output_path
"""
# Prepare output path
self.output_file = QFile(self.output_path)
if not self.output_file.open(QFile.WriteOnly):
raise IOError(self.output_file.errorString())
# Prepare downloaded buffer
self.downloaded_file_buffer = QByteArray()
# Request the url
request = QNetworkRequest(self.url)
self.reply = self.manager.get(request)
self.reply.readyRead.connect(self.get_buffer)
self.reply.finished.connect(self.write_data)
self.manager.requestTimedOut.connect(self.request_timeout)
if self.progress_dialog:
# progress bar
def progress_event(received, total):
"""Update progress.
:param received: Data received so far.
:type received: int
:param total: Total expected data.
:type total: int
"""
# noinspection PyArgumentList
QgsApplication.processEvents()
self.progress_dialog.adjustSize()
human_received = humanize_file_size(received)
human_total = humanize_file_size(total)
label_text = tr("%s : %s of %s" % (
self.prefix_text, human_received, human_total))
self.progress_dialog.setLabelText(label_text)
self.progress_dialog.setMaximum(total)
self.progress_dialog.setValue(received)
# cancel
def cancel_action():
"""Cancel download."""
self.reply.abort()
self.reply.deleteLater()
self.reply.downloadProgress.connect(progress_event)
self.progress_dialog.canceled.connect(cancel_action)
# Wait until finished
# On Windows 32bit AND QGIS 2.2, self.reply.isFinished() always
# returns False even after finished slot is called. So, that's why we
# are adding self.finished_flag (see #864)
while not self.reply.isFinished() and not self.finished_flag:
# noinspection PyArgumentList
QgsApplication.processEvents()
result = self.reply.error()
try:
http_code = int(self.reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute))
except TypeError:
# If the user cancels the request, the HTTP response will be None.
http_code = None
self.reply.abort()
self.reply.deleteLater()
if result == QNetworkReply.NoError:
return True, None
elif result == QNetworkReply.UnknownNetworkError:
return False, tr(
'The network is unreachable. Please check your internet '
'connection.')
elif http_code == 408:
msg = tr(
'Sorry, the server aborted your request. '
'Please try a smaller area.')
LOGGER.debug(msg)
return False, msg
elif http_code == 509:
msg = tr(
'Sorry, the server is currently busy with another request. '
'Please try again in a few minutes.')
LOGGER.debug(msg)
return False, msg
elif result == QNetworkReply.ProtocolUnknownError or \
result == QNetworkReply.HostNotFoundError:
# See http://doc.qt.io/qt-5/qurl-obsolete.html#encodedHost
encoded_host = self.url.toAce(self.url.host())
LOGGER.exception('Host not found : %s' % encoded_host)
return False, tr(
'Sorry, the server is unreachable. Please try again later.')
elif result == QNetworkReply.ContentNotFoundError:
LOGGER.exception('Path not found : %s' % self.url.path())
return False, tr('Sorry, the layer was not found on the server.')
else:
return result, self.reply.errorString()
def get_buffer(self):
"""Get buffer from self.reply and store it to our buffer container."""
buffer_size = self.reply.size()
data = self.reply.read(buffer_size)
self.downloaded_file_buffer.append(data)
def write_data(self):
"""Write data to a file."""
self.output_file.write(self.downloaded_file_buffer)
self.output_file.close()
self.finished_flag = True
def request_timeout(self):
"""The request timed out."""
if self.progress_dialog:
self.progress_dialog.hide()
class XFORMDocument:
"""
class to generate an Xml file that is needed for data collection
using mobile device. The class creates the file and QDOM sections
for holding data once the file is called
"""
def __init__(self, fname):
"""
Initalize the class so that we have a new file
everytime document generation method is called
"""
self.dt_text = QDate()
self.file_handler = FilePaths()
self.doc = QDomDocument()
self.form = None
self.fname = fname
self.doc_with_entities = []
self.supports_doc = self.document()
def document(self):
"""
use the globally defined Document name for supporting document
:return:
"""
global DOCUMENT
return DOCUMENT
def form_name(self):
"""
Format the name for the new file to be created. We need to ensure it is
.xml file.
:return:
"""
if len(self.fname.split(".")) > 1:
return self.fname
else:
return self.fname + "{}".format(DOCEXTENSION)
def set_form_name(self, local_name):
"""
Allow the user to update the name of the file. This method
will be called to return a new file with the local_name given
:param local_name: string
:return: QFile
"""
self.fname = local_name + "{}".format(DOCEXTENSION)
self.form.setFileName(self.fname)
self.create_form()
return self.fname
def create_form(self):
"""
Create an XML file that will be our XFORM Document for reading and writing
We want a new file when everytime we are creating XForm
type: file
:return: file
"""
self.form = QFile(os.path.join(FORM_HOME, self.form_name()))
if not QFileInfo(self.form).suffix() == DOCEXTENSION:
self.form_name()
if not self.form.open(QIODevice.ReadWrite | QIODevice.Truncate
| QIODevice.Text):
return self.form.OpenError
def create_node(self, name):
"""
Create a XML element node
:param name:
:return: node
:rtype: QelementNode
"""
return self.doc.createElement(name)
def create_text_node(self, text):
"""
Create an XML text node
:param text:
:return:
"""
return self.doc.createTextNode(text)
def create_node_attribute(self, node, key, value):
"""
Create an attribute and attach it to the node
:param node: Qnode
:param key: Qnode name
:param value: Qnode value
:return: QNode
"""
return node.setAttribute(key, value)
def xform_document(self):
"""
:return: QDomDocument
"""
return self.doc
def write_to_form(self):
"""
Write data to xml file from the base calling class to an output file created earlier
:return:
"""
if isinstance(self.form, QFile):
self.form.write(self.doc.toByteArray())
self.form.close()
self.doc.clear()
else:
return None
def update_form_data(self):
"""
Update the xml file with changes that the user has made.
Particular section of the document will be deleted or added
:return:
"""
pass
def _download_file(self, url, out_path):
reply = self.__sync_request(url)
local_file = QFile(out_path)
local_file.open(QIODevice.WriteOnly)
local_file.write(reply)
local_file.close()
def parse_xml(self):
"""Parse the xml file. Returns false if there is failure."""
xml_file = QFile(self._xml_path)
if not xml_file.open(QIODevice.ReadOnly):
return False
document = QDomDocument()
if not document.setContent(xml_file):
return False
xml_file.close()
document_element = document.documentElement()
if document_element.tagName() != "qgis_style":
return False
# Get all the symbols
self._symbols = []
symbols_element = document_element.firstChildElement("symbols")
symbol_element = symbols_element.firstChildElement()
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
while not symbol_element.isNull():
if symbol_element.tagName() == "symbol":
symbol = QgsSymbolLayerUtils.loadSymbol(
symbol_element, context)
if symbol:
self._symbols.append({
"name":
symbol_element.attribute("name"),
"symbol":
symbol
})
symbol_element = symbol_element.nextSiblingElement()
# Get all the colorramps
self._colorramps = []
ramps_element = document_element.firstChildElement("colorramps")
ramp_element = ramps_element.firstChildElement()
while not ramp_element.isNull():
if ramp_element.tagName() == "colorramp":
colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element)
if colorramp:
self._colorramps.append({
"name":
ramp_element.attribute("name"),
"colorramp":
colorramp
})
ramp_element = ramp_element.nextSiblingElement()
# Get all the TextFormats - textformats - textformat
self._textformats = []
textformats_element = document_element.firstChildElement("textformats")
textformat_element = textformats_element.firstChildElement()
while not textformat_element.isNull():
if textformat_element.tagName() == "textformat":
textformat = QgsTextFormat()
textformat.readXml(textformat_element, QgsReadWriteContext())
if textformat:
self._textformats.append({
"name":
textformat_element.attribute("name"),
"textformat":
textformat,
})
textformat_element = textformat_element.nextSiblingElement()
# Get all the LabelSettings - labelsettings - labelsetting -
# QgsPalLayerSettings.readXML?
self._labelsettings = []
labels_element = document_element.firstChildElement("labelsettings")
label_element = labels_element.firstChildElement()
while not label_element.isNull():
if label_element.tagName() == "labelsetting":
labelsettings = QgsPalLayerSettings()
labelsettings.readXml(label_element, QgsReadWriteContext())
if labelsettings:
self._labelsettings.append({
"name":
label_element.attribute("name"),
"labelsettings":
labelsettings,
})
label_element = label_element.nextSiblingElement()
return True
def sendOutputFile(self, handler):
format_dict = WFSFormats[self.format]
# read the GML
gml_path = join(self.tempdir, '{}.gml'.format(self.filename))
output_layer = QgsVectorLayer(gml_path, 'qgis_server_wfs_features',
'ogr')
# Temporary file where to write the output
temporary = QTemporaryFile(
join(QDir.tempPath(),
'request-WFS-XXXXXX.{}'.format(format_dict['filenameExt'])))
temporary.open()
output_file = temporary.fileName()
temporary.close()
if output_layer.isValid():
try:
# create save options
options = QgsVectorFileWriter.SaveVectorOptions()
# driver name
options.driverName = format_dict['ogrProvider']
# file encoding
options.fileEncoding = 'utf-8'
# coordinate transformation
if format_dict['forceCRS']:
options.ct = QgsCoordinateTransform(
output_layer.crs(),
QgsCoordinateReferenceSystem(format_dict['forceCRS']),
QgsProject.instance())
# datasource options
if format_dict['ogrDatasourceOptions']:
options.datasourceOptions = format_dict[
'ogrDatasourceOptions']
# write file
if Qgis.QGIS_VERSION_INT >= 31003:
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormatV2(
output_layer, output_file,
QgsProject.instance().transformContext(), options)
else:
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
output_layer, output_file, options)
if write_result != QgsVectorFileWriter.NoError:
handler.appendBody(b'')
self.logger.critical(error_message)
return False
except Exception as e:
handler.appendBody(b'')
self.logger.critical(str(e))
return False
if format_dict['zip']:
# compress files
import zipfile
# noinspection PyBroadException
try:
import zlib # NOQA
compression = zipfile.ZIP_DEFLATED
except Exception:
compression = zipfile.ZIP_STORED
# create the zip file
zip_file_path = join(self.tempdir, '%s.zip' % self.filename)
with zipfile.ZipFile(zip_file_path, 'w') as zf:
# add all files
zf.write(join(
self.tempdir,
'%s.%s' % (self.filename, format_dict['filenameExt'])),
compress_type=compression,
arcname='%s.%s' %
(self.typename, format_dict['filenameExt']))
for e in format_dict['extToZip']:
file_path = join(self.tempdir,
'%s.%s' % (self.filename, e))
if exists(file_path):
zf.write(file_path,
compress_type=compression,
arcname='%s.%s' % (self.typename, e))
zf.close()
f = QFile(zip_file_path)
if f.open(QFile.ReadOnly):
ba = f.readAll()
handler.appendBody(ba)
return True
else:
# return the file created without zip
f = QFile(output_file)
if f.open(QFile.ReadOnly):
ba = f.readAll()
handler.appendBody(ba)
return True
handler.appendBody(b'')
self.logger.critical('Error no output file')
return False
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
# Validate if the user has specified the data source
if not LayoutUtils.get_stdm_data_source_for_layout(self.composition()):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"data source name for the document composition."))
return
# Assert if the referenced table name has been set
if not LayoutUtils.get_stdm_referenced_table_for_layout(
self.composition()):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"referenced table name for the selected data source."))
return
# If it is a new unsaved document template then prompt for the document name.
#template_path = self.composition().customProperty('variable_template_path', None)
template_path = self.variable_template_path
if template_path is None:
docName, ok = QInputDialog.getText(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Template Name"),
QApplication.translate("ComposerWrapper",
"Please enter the template name below"),
)
if not ok:
return
if ok and not docName:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate("ComposerWrapper",
"Please enter a template name!"))
self.saveTemplate()
if ok and docName:
templateDir = self._composerTemplatesPath()
if templateDir is None:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper",
"Directory for document templates cannot not be found."
))
return
absPath = templateDir + "/" + docName + ".sdt"
# Check if there is an existing document with the same name
caseInsenDic = CaseInsensitiveDict(documentTemplates())
if docName in caseInsenDic:
result = QMessageBox.warning(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Existing Template"),
"'{0}' {1}.\nDo you want to replace the "
"existing template?".format(
docName,
QApplication.translate("ComposerWrapper",
"already exists")),
QMessageBox.Yes | QMessageBox.No)
if result != QMessageBox.Yes:
return
else:
# Delete the existing template
delFile = QFile(absPath)
remove_status = delFile.remove()
if not remove_status:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Delete Error"),
"'{0}' {1}.".format(
docName,
QApplication.translate(
"ComposerWrapper",
"template could not be removed by the system,"
" please remove it manually from the document templates directory."
)))
return
docFile = QFile(absPath)
template_path = absPath
else:
docFile = QFile(template_path)
# else:
# return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Save Operation Error"),
"{0}\n{1}".format(
QApplication.translate("ComposerWrapper",
"Could not save template file."),
docFile.errorString()))
return
templateDoc = QDomDocument()
template_name = docFileInfo.completeBaseName()
# Catch exception raised when writing items' elements
try:
self._writeXML(templateDoc, template_name)
except DummyException as exc:
msg = str(exc)
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Save Error"), msg)
docFile.close()
docFile.remove()
return
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Save Error"),
QApplication.translate("ComposerWrapper",
"Could not save template file."))
return
else:
self.mainWindow().setWindowTitle(template_name)
self.composition().setCustomProperty('variable_template_path',
template_path)
docFile.close()
layer.editFormConfig().setWidgetConfig(idx, cfg)
# value maps
if layer.editFormConfig().widgetType(idx) == 'ValueMap':
cfg = layer.editFormConfig().widgetConfig(idx)
for key in cfg.keys():
trans = get_table_translation(cur, cfg[key])
if trans:
cfg[trans] = cfg[key]
del cfg[key]
layer.editFormConfig().setWidgetConfig(idx, cfg)
# update styles from other project
if 'style_file' in config_data:
errMsg = ''
file = QFile(config_data['style_file'])
file.open(QFile.ReadOnly | QFile.Text)
doc = QDomDocument()
doc.setContent(file)
root = doc.elementsByTagName('qgis.custom.style')
nodes = root.at(0).childNodes()
for i in range(0, nodes.count()):
elem = nodes.at(i).toElement()
if elem.tagName() != 'layer' or not elem.hasAttribute('id'):
continue
layer_id = elem.attribute('id')
if layer_id not in style_layer_ids:
print('skipping ', layer_id)
layer = QgsProject.instance().mapLayer(layer_id)
if not layer:
print('layer not found', layer_id)
continue
class QgsPluginInstallerInstallingDialog(QDialog, Ui_QgsPluginInstallerInstallingDialogBase):
# ----------------------------------------- #
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
self.url = QUrl(plugin["download_url"])
self.redirectionCounter = 0
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.requestDownloading()
def requestDownloading(self):
self.request = QNetworkRequest(self.url)
self.request.setAttribute(QNetworkRequest.Attribute(QgsNetworkRequestParameters.AttributeInitiatorClass), "QgsPluginInstallerInstallingDialog")
authcfg = repositories.all()[self.plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, str):
if not QgsApplication.authManager().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def exec_(self):
if self.request is None:
return QDialog.Rejected
QDialog.exec_(self)
# ----------------------------------------- #
def result(self):
return self.mResult
# ----------------------------------------- #
def stateChanged(self, state):
messages = [
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Installing…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Resolving host name…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Connecting…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Host connected. Sending request…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Downloading data…"),
self.tr("Idle"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Closing connection…"),
self.tr("Error")
]
self.labelState.setText(messages[state])
# ----------------------------------------- #
def readProgress(self, done, total):
if total > 0:
self.progressBar.setMaximum(total)
self.progressBar.setValue(done)
# ----------------------------------------- #
def requestFinished(self):
reply = self.sender()
self.buttonBox.setEnabled(False)
if reply.error() != QNetworkReply.NoError:
self.mResult = reply.errorString()
if reply.error() == QNetworkReply.OperationCanceledError:
self.mResult += "<br/><br/>" + QCoreApplication.translate("QgsPluginInstaller", "If you haven't canceled the download manually, it might be caused by a timeout. In this case consider increasing the connection timeout value in QGIS options.")
self.reject()
reply.deleteLater()
return
elif reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) in (301, 302):
redirectionUrl = reply.attribute(QNetworkRequest.RedirectionTargetAttribute)
self.redirectionCounter += 1
if self.redirectionCounter > 4:
self.mResult = QCoreApplication.translate("QgsPluginInstaller", "Too many redirections")
self.reject()
reply.deleteLater()
return
else:
if redirectionUrl.isRelative():
redirectionUrl = reply.url().resolved(redirectionUrl)
# Fire a new request and exit immediately in order to quietly destroy the old one
self.url = redirectionUrl
self.requestDownloading()
reply.deleteLater()
return
self.file.open(QFile.WriteOnly)
self.file.write(reply.readAll())
self.file.close()
self.stateChanged(0)
reply.deleteLater()
pluginDir = qgis.utils.home_plugin_path
tmpPath = self.file.fileName()
# make sure that the parent directory exists
if not QDir(pluginDir).exists():
QDir().mkpath(pluginDir)
# if the target directory already exists as a link, remove the link without resolving:
QFile(pluginDir + str(QDir.separator()) + self.plugin["id"]).remove()
try:
unzip(str(tmpPath), str(pluginDir)) # test extract. If fails, then exception will be raised and no removing occurs
# removing old plugin files if exist
removeDir(QDir.cleanPath(pluginDir + "/" + self.plugin["id"])) # remove old plugin if exists
unzip(str(tmpPath), str(pluginDir)) # final extract.
except:
self.mResult = self.tr("Failed to unzip the plugin package. Probably it's broken or missing from the repository. You may also want to make sure that you have write permission to the plugin directory:") + "\n" + pluginDir
self.reject()
return
try:
# cleaning: removing the temporary zip file
QFile(tmpPath).remove()
except:
pass
self.close()
# ----------------------------------------- #
def abort(self):
if self.reply.isRunning():
self.reply.finished.disconnect()
self.reply.abort()
del self.reply
self.mResult = self.tr("Aborted by user")
self.reject()
def loadTemplate(self, filePath):
"""
Loads a document template into the view and updates the necessary STDM-related composer items.
"""
if not QFile.exists(filePath):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("OpenTemplateConfig",
"Open Template Error"),
QApplication.translate(
"OpenTemplateConfig",
"The specified template does not exist."))
return
copy_file = filePath.replace('sdt', 'cpy')
# remove existing copy file
if QFile.exists(copy_file):
copy_template = QFile(copy_file)
copy_template.remove()
orig_template_file = QFile(filePath)
self.setDocumentFile(orig_template_file)
# make a copy of the original
result = orig_template_file.copy(copy_file)
#templateFile = QFile(filePath)
# work with copy
templateFile = QFile(copy_file)
self.copy_template_file = templateFile
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Open Operation Error"),
"{0}\n{1}".format(
QApplication.translate("ComposerWrapper",
"Cannot read template file."),
templateFile.errorString()))
return
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
table_config_collection = TableConfigurationCollection.create(
templateDoc)
'''
First load vector layers for the table definitions in the config
collection before loading the composition from file.
'''
load_table_layers(table_config_collection)
self.clearWidgetMappings()
#Load items into the composition and configure STDM data controls
self.composition().loadFromTemplate(templateDoc)
#Load data controls
composerDS = ComposerDataSource.create(templateDoc)
#Set title by appending template name
title = QApplication.translate("STDMPlugin",
"STDM Document Designer")
composer_el = templateDoc.documentElement()
if not composer_el is None:
template_name = ""
if composer_el.hasAttribute("title"):
template_name = composer_el.attribute("title", "")
elif composer_el.hasAttribute("_title"):
template_name = composer_el.attribute("_title", "")
if template_name:
win_title = "{0} - {1}".format(title, template_name)
self.mainWindow().setWindowTitle(template_name)
self._configure_data_controls(composerDS)
#Load symbol editors
spatialFieldsConfig = SpatialFieldsConfiguration.create(
templateDoc)
self._configureSpatialSymbolEditor(spatialFieldsConfig)
#Load photo editors
photo_config_collection = PhotoConfigurationCollection.create(
templateDoc)
self._configure_photo_editors(photo_config_collection)
# Load table editors
self._configure_table_editors(table_config_collection)
#Load chart property editors
chart_config_collection = ChartConfigurationCollection.create(
templateDoc)
self._configure_chart_editors(chart_config_collection)
# Load QR code property editors
qrc_config_collection = QRCodeConfigurationCollection.create(
templateDoc)
self._configure_qr_code_editors(qrc_config_collection)
self._sync_ids_with_uuids()