various

Author: patricev

.gitignore

@@ -10,6 +10,7 @@ test/testtempfiles/
 test/datas/lamia_*
 sandbox/*/
 frontend/
+secrets/
 
 arteliasite/node_modules
 arteliasite/lamiacarto/static/lamiacarto/bundle

api/dbasemanager/configresourcefinder.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+
+"""
+This file is part of LAMIA.
+
+    LAMIA is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    LAMIA is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Foobar.  If not, see <https://www.gnu.org/licenses/>.
+
+"""
+"""
+  * Copyright (c) 2017-2020 ARTELIA Commit <[email protected]>
+  * 
+  * SPDX-License-Identifier: GPL-3.0-or-later
+  * License-Filename: LICENSING.md
+ """
+
+import os
+import Lamia
+
+
+class ConfigResourcefinder:
+    def __init__(self, dbaseparser):
+        self.dbaseparser = dbaseparser
+
+    def findResource(self, resourcecategory, resourcename):
+        """find a resource in different config dirs :
+            * first is project config dir
+            * second is lamia worktype config dir
+            * last is lamia base config dir
+
+        :param resourcecategory: Directory of particulary module
+        :type resourcecategory: string
+        :param resourcename: filename of particulary module
+        :type resourcename: string
+        :return: complete filepath
+        :rtype: string
+        """
+        dirs = [
+            os.path.join(
+                self.dbaseparser.completePathOfFile(
+                    self.dbaseparser.dbaseressourcesdirectory
+                ),
+                "config",
+            ),
+            os.path.join(
+                os.path.dirname(Lamia.config.__file__), self.dbaseparser.worktype
+            ),
+            os.path.join(
+                os.path.dirname(Lamia.config.__file__),
+                self.dbaseparser.worktype.split("_")[0],
+            ),
+        ]
+
+        for dirpath in dirs:
+            tempath = os.path.join(dirpath, resourcecategory, resourcename)
+            print("tempath", tempath)
+            if os.path.isfile(tempath):
+                return tempath
+
+        return None
+

api/dbasemanager/dbaseparserabstract.py

@@ -40,6 +40,7 @@
 from Lamia.api.libslamia.lamiareg.updatereg import updateWinReg
 from .dbconfigreader import DBconfigReader
 from .dbaseofflinemanager import DBaseOfflineManager
+from .configresourcefinder import ConfigResourcefinder
 from Lamia.qgisiface.iface.ifaceabstractconnector import LamiaIFaceAbstractConnectors
 from . import dbaseutils
 
@@ -57,7 +58,14 @@
     "BYTEA": "BLOB",
 }
 
-PROJECTCONFIGDIRS = ["dbase", "rapporttools", "styles", "importtools"]
+PROJECTCONFIGDIRS = [
+    "dbase",
+    "lamiareport",
+    "qgsstyles",
+    "lamiaimport",
+    "assets",
+    "lamiaexportshp",
+]
 # PROJECTCONFIGDIRS = ["dbase", "qgswidgets", "qgsstyles", "lamiacost", "lamiaexportshp"]
 THUMBNAIL_SIZE = 256
 
@@ -102,6 +110,9 @@ def __init__(self, parserfactory=None, messageinstance=None):
         #:the offline manager instance
         self.dbaseofflinemanager = DBaseOfflineManager(self)
 
+        # config resourcefinder
+        self.configresourcefinder = ConfigResourcefinder(self)
+
         #:for debug purpose
         self.printsql = False
 
@@ -307,6 +318,7 @@ def loadDBase(self, **kwargs):
         else:
             sql = "SELECT metier, repertoireressources,crs, version, workversion, variante   FROM Basedonnees"
         query = self.query(sql)
+
         worktype, resdir, crs, version, workversion, variante = [
             row[0:6] for row in query
         ][0]

api/libs/odsreader/ODSReader.py

@@ -14,10 +14,8 @@
 
 # Thanks to grt for the fixes
 import os, sys
-import Lamia.api
 
-lamiaapipath = os.path.join(os.path.dirname(Lamia.api.__file__))
-libspath = os.path.join(lamiaapipath, "libs")
+libspath = os.path.normpath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(libspath)
 
 import odf.opendocument

api/libslamia/lamiaimport/lamiaimport.py

@@ -30,22 +30,33 @@
 from pprint import pprint
 
 
-class ImportCore():
+class ImportCore:
 
-    POSTPROTOOLNAME = 'importtools'
+    POSTPROTOOLNAME = "lamiaimport"
 
-
-    def __init__(self, dbaseparser,messageinstance=None):
-        #super(ExportShapefileTool, self).__init__(dbase, dialog, linkedtreewidget, gpsutil, parentwidget, parent=parent)
+    def __init__(self, dbaseparser, messageinstance=None):
+        # super(ExportShapefileTool, self).__init__(dbase, dialog, linkedtreewidget, gpsutil, parentwidget, parent=parent)
         self.dbase = dbaseparser
         self.messageinstance = messageinstance
-        self.tooldir = os.path.join(os.path.dirname(__file__), self.dbase.worktype.lower())
-
-        self.confdataplugin = os.path.join(os.path.dirname(__file__), self.dbase.worktype.lower())
-        self.confdataproject = os.path.join(self.dbase.dbaseressourcesdirectory, 'config', self.POSTPROTOOLNAME)
-
-
-    def importCleanedDatas(self, rawtablename=None, table_field_list=None, values=None, geoms=None, returnfield=None):
+        self.tooldir = os.path.join(
+            os.path.dirname(__file__), self.dbase.worktype.lower()
+        )
+
+        self.confdataplugin = os.path.join(
+            os.path.dirname(__file__), self.dbase.worktype.lower()
+        )
+        self.confdataproject = os.path.join(
+            self.dbase.dbaseressourcesdirectory, "config", self.POSTPROTOOLNAME
+        )
+
+    def importCleanedDatas(
+        self,
+        rawtablename=None,
+        table_field_list=None,
+        values=None,
+        geoms=None,
+        returnfield=None,
+    ):
 
         """
 
@@ -59,84 +70,84 @@ def importCleanedDatas(self, rawtablename=None, table_field_list=None, values=No
 
         debug = False
 
-        tablesnames = np.array([result.split('.')[0] for result in table_field_list])
-        fieldsnames = np.array([result.split('.')[1] for result in table_field_list])
+        tablesnames = np.array([result.split(".")[0] for result in table_field_list])
+        fieldsnames = np.array([result.split(".")[1] for result in table_field_list])
 
         parenttables = [rawtablename] + self.dbase.getParentTable(rawtablename)
-        self.messageinstance.createProgressBar(inittext="import ...", maxvalue=len(values))
+        self.messageinstance.createProgressBar(
+            inittext="import ...", maxvalue=len(values)
+        )
 
         self.dbase.beginTransaction()
 
         # cas des couches enfant de descriptionsystem
         for i, valueline in enumerate(values):
             valueline = np.array(valueline)
-            #self.setLoadingProgressBar(progress, i)
-            if i%50 == 0:
+            # self.setLoadingProgressBar(progress, i)
+            if i % 50 == 0:
                 self.messageinstance.updateProgressBar(i)
 
             pktablename = self.dbase.createNewFeature(rawtablename)
 
             for tablename in parenttables:
-                pktable = self.dbase.getValuesFromPk(rawtablename + '_qgis',
-                                                        'pk_' + tablename.lower(),
-                                                        pktablename )
+                pktable = self.dbase.getValuesFromPk(
+                    rawtablename + "_qgis", "pk_" + tablename.lower(), pktablename
+                )
                 indexobjectvalues = np.where(np.array(tablesnames) == tablename)
                 lisfield = fieldsnames[indexobjectvalues]
                 listvalues = valueline[indexobjectvalues]
-                self.updateTable( tablename, lisfield, listvalues, pktable)
+                self.updateTable(tablename, lisfield, listvalues, pktable)
 
-                if 'geom' in self.dbase.dbasetables[tablename].keys():
-                    if self.dbase.__class__.TYPE == 'spatialite':
+                if "geom" in self.dbase.dbasetables[tablename].keys():
+                    if self.dbase.__class__.TYPE == "spatialite":
                         geomsql = "CastToSingle(CastToXY(ST_GeomFromText('"
                         geomsql += geoms[i]
                         geomsql += "', " + str(self.dbase.crsnumber) + ")))"
-                    elif self.dbase.__class__.TYPE == 'postgis':
+                    elif self.dbase.__class__.TYPE == "postgis":
                         geomsql = "ST_GeometryN(ST_Force2D(ST_GeomFromText('"
                         geomsql += geoms[i]
                         geomsql += "', " + str(self.dbase.crsnumber) + ")),0)"
 
-                    self.updateTable( tablename, ['geom'], [geomsql], pktable)
-
-        
+                    self.updateTable(tablename, ["geom"], [geomsql], pktable)
 
         self.dbase.commitTransaction()
 
         self.messageinstance.closeProgressBar()
 
-    def updateTable(self,  tablename, listfield, listvalues, pkvalue):
+    def updateTable(self, tablename, listfield, listvalues, pkvalue):
 
         sql = "UPDATE " + tablename + " SET "
         for i, fieldname in enumerate(listfield):
-            if listvalues[i] != '':
+            if listvalues[i] != "":
                 sql += fieldname + " = "
-                sql += self.convertDataType(tablename, fieldname, listvalues[i]) + ', '
+                sql += self.convertDataType(tablename, fieldname, listvalues[i]) + ", "
 
-        if sql[-2:] == ', ':
+        if sql[-2:] == ", ":
             sql = sql[:-2]
-        sql += " WHERE pk_" + tablename.lower()  +" = " + str(pkvalue)
+        sql += " WHERE pk_" + tablename.lower() + " = " + str(pkvalue)
         query = self.dbase.query(sql, docommit=False)
 
-    def convertDataType(self, table,field, value):
-        if field == 'geom':
+    def convertDataType(self, table, field, value):
+        if field == "geom":
             return str(value)
 
         if self.dbase.utils.isAttributeNull(value):
-            return 'NULL'
+            return "NULL"
 
-        typevalue = self.dbase.dbasetables[table]['fields'][field]['PGtype']
-        #getConstraintRawValueFromText(self, table, field, txt):
+        typevalue = self.dbase.dbasetables[table]["fields"][field]["PGtype"]
+        # getConstraintRawValueFromText(self, table, field, txt):
         rawvalue = self.dbase.getConstraintRawValueFromText(table, field, value)
 
-        if 'VARCHAR' in typevalue:
+        if "VARCHAR" in typevalue:
             returnvalue = "'" + str(rawvalue) + "'"
-        elif 'TIMESTAMP' in typevalue:
+        elif "TIMESTAMP" in typevalue:
             returnvalue = "'" + str(rawvalue) + "'"
-        elif 'TEXT' in typevalue:
+        elif "TEXT" in typevalue:
             returnvalue = "'" + str(rawvalue) + "'"
         else:
             returnvalue = str(rawvalue)
 
         return returnvalue
 
-    def postImport(self,layerfeat, pkobjet=None, pkdessys=None, pksubdessys=None):
+    def postImport(self, layerfeat, pkobjet=None, pkdessys=None, pksubdessys=None):
         pass

api/libslamia/lamiareport/lamiareport.py

@@ -39,7 +39,7 @@
 
 class ReportCore:
 
-    POSTPROTOOLNAME = "reporttools"
+    POSTPROTOOLNAME = "lamiareport"
     if qgis.utils.iface is None:
         LAUNCHINQTHREAD = False
     else:
@@ -948,14 +948,18 @@ def processImages(self, newComposition, atlas, atlasfeat):
                 imageresult = self.getNumberedResource(atlasfeat, table, ressourcenum)
 
             elif self.atlasconfData["images"][imageitemname][0:4] == "logo":
-                imagepath = os.path.join(
-                    os.path.dirname(__file__),
-                    "..",
-                    "..",
-                    "DBASE",
-                    "utils",
-                    self.atlasconfData["images"][imageitemname] + ".png",
+                imagepath = self.dbase.configresourcefinder.findResource(
+                    "assets", self.atlasconfData["images"][imageitemname] + ".png"
                 )
+
+                # imagepath = os.path.join(
+                #     os.path.dirname(__file__),
+                #     "..",
+                #     "..",
+                #     "DBASE",
+                #     "utils",
+                #     self.atlasconfData["images"][imageitemname] + ".png",
+                # )
                 imageresult = os.path.join(imagepath)
 
             else:
@@ -1413,7 +1417,10 @@ def fillComposerMapsWihLayers(self, newComposition, coveragelayer):
                                     "ogr",
                                 )
                                 if qgis.utils.iface is not None:
-                                    rlayer.renderer().setOpacity(0.5)
+                                    try:  # if raster layer
+                                        rlayer.renderer().setOpacity(0.5)
+                                    except:
+                                        pass
                                 # qgis.core.QgsProject.instance().addMapLayer(
                                 self.project.addMapLayer(rlayer, False)
                                 layersformapcomposer.append(rlayer)
@@ -1486,7 +1493,8 @@ def getOrderedPksForAtlas(self, coveragelayer):
             orderedpks = self.orderPksAlongPath(coveragelayer, self.pkzonegeolist)
         else:
             # orderedpks[0] = [feat[self.atlasconfData['atlaslayerid']] for feat in coveragelayer.getFeatures()]
-            orderedpks[0] = [feat.id() for feat in coveragelayer.getFeatures()]
+            # orderedpks[0] = [feat.id() for feat in coveragelayer.getFeatures()]
+            orderedpks = self.getPksByzoneGeo(coveragelayer, self.pkzonegeolist)
 
         if len(orderedpks) == 0:
             orderedpks[0] = [feat.id() for feat in coveragelayer.getFeatures()]
@@ -1631,6 +1639,27 @@ def orderPksAlongPath(self, coveragelayer, zonegeopks=[]):
             self.logger.debug("orderedpks %s", str(orderedpks))
         return orderedpks
 
+    def getPksByzoneGeo(self, coveragelayer, zonegeopks=[]):
+        if len(zonegeopks) == 0:
+            sql = "SELECT pk_geoarea, ST_AsText(geom) FROM geoarea "
+            query = self.dbase.query(sql)
+            zonegeopks = [row[0] for row in query]
+            # zonegeogeoms = [row[1] for row in query]
+
+        zonegeopksstr = [str(elem) for elem in zonegeopks]
+        sql = f"SELECT pk_geoarea, ST_AsText(geom) FROM geoarea WHERE pk_geoarea in ({','.join(zonegeopksstr)})"
+        query = self.dbase.query(sql)
+
+        orderedpks = {}
+        for zonegeopk, zonegeogeom in query:
+            orderedpks[zonegeopk] = []
+            for feat in coveragelayer.getFeatures():
+                if feat.geometry().intersects(
+                    qgis.core.QgsGeometry.fromWkt(zonegeogeom)
+                ):
+                    orderedpks[zonegeopk].append(feat.id())
+        return orderedpks
+
     def initPrinterAndPainter(self, newComposition):
         """
         initialise le self.priner et le self.painter pour accuilir l'impression

api/libslamia/sirsconverter/09_test_APn_base2.py

@@ -7,11 +7,11 @@
 
 from qgis.core import QgsGeometry
 
-from Lamia.Lamia.api.libs.cloudant.client import Cloudant
-from Lamia.Lamia.api.libs.cloudant.error import CloudantException
-from Lamia.Lamia.api.libs.cloudant.result import Result, ResultByKey, QueryResult
-from Lamia.Lamia.api.libs.cloudant.query import Query
-from Lamia.Lamia.main.DBaseParser import DBaseParser
+from Lamia.api.libs.cloudant.client import Cloudant
+from Lamia.api.libs.cloudant.error import CloudantException
+from Lamia.api.libs.cloudant.result import Result, ResultByKey, QueryResult
+from Lamia.api.libs.cloudant.query import Query
+from Lamia.main.DBaseParser import DBaseParser
 
 try:
     from pyspatialite import dbapi2 as db