# -*- coding: utf-8 -*-
"""
Copyright (c) 2016 Biuro Urządzania Lasu i Geodezji Leśnej

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), 
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
OTHER DEALINGS IN THE SOFTWARE.
"""
import os
from PyQt5.QtCore import *
from PyQt5.QtGui import *

from qgis.core import *
from qgis.gui import *

from Mapa_PU.kontroler import komunikaty
import datetime

from shapely.geometry import Polygon, MultiPolygon 
from shapely.ops import cascaded_union
from shapely.wkt import loads
from shapely.wkt import dumps 

#from Mapa_PU.test.debug_dialog import DebugDialog
from Mapa_PU.widok.pasek_wiadomosci import PasekWiadomosc
from Mapa_PU.kontroler.metody_globalne import otworzPlik, zapiszText
from PyQt5.QtWidgets import QProgressBar
from Mapa_PU.model.wynik_kontroli import WynikKontroli, Result, TypeOfControl
from Mapa_PU.model.baza_danych import Baza
from Mapa_PU.model.kontrola_geometryczna import KontrolaGeometryczna
from Mapa_PU.kontroler.excel import ExcelError, Excel
import processing
import datetime
from Mapa_PU.model import date_helper
from qgis.core import (QgsTaskManager, QgsMessageLog,
                       QgsProcessingAlgRunnerTask, QgsApplication,
                       QgsProcessingContext, QgsProcessingFeedback,
                       QgsProject, QgsVectorLayer,QgsTask,QgsVectorLayerUtils)
import itertools


class KontrolaGeometrii(QObject):
    """Wykonuje kontrolę geometrii"""
    
    #zakonczenie = QtCore.pyqtSignal(object)
    #blad = QtCore.pyqtSignal(Exception, basestring)
    #postep = QtCore.pyqtSignal(float)
    #komunikat=QtCore.pyqtSignal('QString')
    
    def __init__(self,iface,root,konfiguracja,mapa,projekt,wersja,baza_kontroli:Baza):
        """Constructor"""
        self.iface = iface
        self.konfiguracja = konfiguracja
        self.mapa= mapa
        self.projekt=projekt
        self.__wersja=wersja
        self.__root=root
        super(KontrolaGeometrii,self).__init__()
         
        
        self._testxt = u''
        
        self._log_datetime = '{}.txt'.format(datetime.date.today())#str(datetime.datetime.now())[:-7].replace(':','').replace(' ','_') +".txt"
        self._log_plik = "kontrola_geometryczna_" + self._log_datetime
        self._log_sciezka = os.path.join( os.path.join(self.konfiguracja.sciezka,'Kontrole'), self._log_plik )
        
        self._log =  u'|============================================================|\n'
        self._log += u'|' + self._log_plik.center(60) + '|\n'
        self._log += u'|============================================================|\n'
        self._log += u'\n\n'
        
        self.atrybuty_warstw = {}
        
        # Warstwa "O_PODST":
        self.atrybuty_warstw['O_PODST'] = QgsFields()
        self.atrybuty_warstw['O_PODST'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['O_PODST'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['O_PODST'].append(QgsField("ADR_ADM", QVariant.String, "String", 25))
        self.atrybuty_warstw['O_PODST'].append(QgsField("NR_EW", QVariant.String,"String",25))
        self.atrybuty_warstw['O_PODST'].append(QgsField("NR_KONT", QVariant.Int, "Integer", 4))
        self.atrybuty_warstw['O_PODST'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        # Warstwa "UZYTKI":      
        self.atrybuty_warstw['UZYTKI'] = QgsFields()
        self.atrybuty_warstw['UZYTKI'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['UZYTKI'].append(QgsField("ADR_ADM", QVariant.String, "String", 25))
        self.atrybuty_warstw['UZYTKI'].append(QgsField("NR_KONT", QVariant.Int, "Integer", 4))
        self.atrybuty_warstw['UZYTKI'].append(QgsField("NR_EW", QVariant.String,"String",25))
        self.atrybuty_warstw['UZYTKI'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        # Warstwa "DZ_EWID":      
        self.atrybuty_warstw['DZ_EWID'] = QgsFields()
        self.atrybuty_warstw['DZ_EWID'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['DZ_EWID'].append(QgsField("ADR_ADM", QVariant.String, "String", 25))  
        self.atrybuty_warstw['DZ_EWID'].append(QgsField("NR_EW", QVariant.String,"String",25))      
        self.atrybuty_warstw['DZ_EWID'].append(QgsField("Opis", QVariant.String, "String", 80))
             
        self.atrybuty_warstw['OS_POW'] = QgsFields()
        self.atrybuty_warstw['OS_POW'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['OS_POW'].append(QgsField("KOD_OSOBL", QVariant.String, "String",12))
        self.atrybuty_warstw['OS_POW'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['OS_POW'].append(QgsField("POW_OSOBL", QVariant.Double, "Double",11,2))
        self.atrybuty_warstw['OS_POW'].append(QgsField("NR_OSOBL", QVariant.Int, "Integer", 4))        
        self.atrybuty_warstw['OS_POW'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['PNSW'] = QgsFields()
        self.atrybuty_warstw['PNSW'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['PNSW'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['PNSW'].append(QgsField("KOD_PNSW", QVariant.String, "String", 12))
        self.atrybuty_warstw['PNSW'].append(QgsField("NR_PNSW", QVariant.Int, "Integer", 4))
        self.atrybuty_warstw['PNSW'].append(QgsField("NR_EW", QVariant.String, "String",25))
        self.atrybuty_warstw['PNSW'].append(QgsField("ADR_ADM", QVariant.String, "String", 25))
        self.atrybuty_warstw['PNSW'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['ODDZIAL'] = QgsFields()
        self.atrybuty_warstw['ODDZIAL'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['ODDZIAL'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        
        self.atrybuty_warstw['POW'] = QgsFields()
        self.atrybuty_warstw['POW'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['POW'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['POW'].append(QgsField("L_EWID", QVariant.String, "String",1))
        self.atrybuty_warstw['POW'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['OS_PKT'] = QgsFields()
        self.atrybuty_warstw['OS_PKT'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['OS_PKT'].append(QgsField("KOD_OSOBL", QVariant.String, "String", 12))
        self.atrybuty_warstw['OS_PKT'].append(QgsField("NR_OSOBL", QVariant.Int, "Integer", 4))
        self.atrybuty_warstw['OS_PKT'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['OS_PKT'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['OS_POW'] = QgsFields()
        self.atrybuty_warstw['OS_POW'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['OS_POW'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['OS_POW'].append(QgsField("KOD_OSOBL", QVariant.String, "String", 12))
        self.atrybuty_warstw['OS_POW'].append(QgsField("NR_OSOBL", QVariant.Int, "Integer", 4))
        self.atrybuty_warstw['OS_POW'].append(QgsField("POW_OSOBL", QVariant.Double, "Double", 11, 2))
        self.atrybuty_warstw['OS_POW'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['OP_POW'] = QgsFields()
        self.atrybuty_warstw['OP_POW'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['OP_POW'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['OP_POW'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.atrybuty_warstw['OP_ODDZ'] = QgsFields()
        self.atrybuty_warstw['OP_ODDZ'].append(QgsField("ID", QVariant.Int, "Integer", 6))
        self.atrybuty_warstw['OP_ODDZ'].append(QgsField("ADR_BDL", QVariant.String, "String", 25))
        self.atrybuty_warstw['OP_ODDZ'].append(QgsField("Opis", QVariant.String, "String", 80))
        
        self.pola_wymagane_warstw = {}
        self.pola_wymagane_warstw['O_PODST'] = ['ID','ADR_BDL','ADR_ADM','NR_EW','NR_KONT']
        self.pola_wymagane_warstw['DZ_EWID'] = ['NR_EW','ADR_ADM']
        self.pola_wymagane_warstw['UZYTKI']  = ['ID','ADR_ADM','NR_EW','NR_KONT']
        self.pola_wymagane_warstw['ODDZIAL'] = ['ADR_BDL']
        self.pola_wymagane_warstw['POW']     = ['ADR_BDL']
        self.pola_wymagane_warstw['PNSW']    = ['ID', 'ADR_BDL', 'KOD_PNSW', 'NR_PNSW', 'NR_EW', 'ADR_ADM']
        self.pola_wymagane_warstw['LINIE']   = ['KOD','SZER']
        self.pola_wymagane_warstw['OP_ODDZ'] = ['ADR_BDL']
        self.pola_wymagane_warstw['OP_POW']  = ['ADR_BDL']
        self.pola_wymagane_warstw['OS_PKT']  = ['KOD_OSOBL','NR_OSOBL','ADR_BDL']
        self.pola_wymagane_warstw['OS_POW']  = ['KOD_OSOBL', 'ADR_BDL', 'POW_OSOBL', 'NR_OSOBL']
        
        #Konfiguracja uruchamiania kontroli
        self.__kontrole=self.__konfiguruj(baza_kontroli)
    
    def __konfiguruj(self,baza_kontroli:Baza)->[]:
        """Konfiguracja kontroli geometrycznych
        :params baza_kontroli:Baza konfiguracyjna
        """
        try:
            kontrole=dict()
            sql='SELECT kontrole_geometryczne_konfiguracja.id, kontrole_geometryczne_konfiguracja.kod, kontrole_geometryczne_konfiguracja.wykonaj FROM kontrole_geometryczne_konfiguracja;'
            baza_kontroli.polaczOdbc()
            tabela=baza_kontroli.wykonajZapytanie(sql)
            baza_kontroli.zamknijPolaczenie()
            for wiersz in tabela:
                kontrole[wiersz[1]]=KontrolaGeometryczna(wiersz[1],wiersz[2])
            return kontrole
        except Exception as e:
            raise e 
        
    def zawieranieWarstwPkt(self,polygons_name:str,points_name:str,expresion:str,message:str):
        """Sprawdza zawieranie warstwy punktowej w poligonowej
        """
        try:
            polygons=self.mapa.warstwaRejestr(polygons_name)
            points=self.mapa.warstwaRejestr(points_name)
            #Naprawa warstw, konieczna bo czasem występuje błąd na difference
            #features_polygons=processing.run("native:fixgeometries", {'INPUT':polygons,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #features_points=processing.run("native:fixgeometries", {'INPUT':points,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            layer=processing.run("native:joinbynearest", {'INPUT':points,'INPUT_2':polygons,'FIELDS_TO_COPY':[],'DISCARD_NONMATCHING':False,'PREFIX':'','NEIGHBORS':1,'MAX_DISTANCE':None,'OUTPUT':'TEMPORARY_OUTPUT'})
            #exp=QgsFeatureRequest().setFilterExpression('"ADR_BDL"!="ADR_BDL_2" or "distance">0')
            exp=QgsFeatureRequest().setFilterExpression(expresion)
            return [(message.format(feature['ID'],feature['ID_2']),feature) for feature in list(layer['OUTPUT'].getFeatures(exp))]
            #features=[f for f in list(layer['OUTPUT'].getFeatures()) if f['ADR_BDL']!=f['ADR_BDL_2'] or f['distance']>0]
            #return features
        except Exception as e:
            features=[]
            features.append(self.error_message(lpolygons_name,e,points_name))
            return features
    
    def zawieranieWarstwPoligonowych(self,pasek_wiadomosci,layer_containing_name:str, included_layer_name:str,field_names:[],expresion:str, area=2.0,size=0.020)->[]:
        """Kontrola zawierania się dwuch warstw
        :param layer_containing: warstwa zawierajaca inną warstwę
        :param included_layer: warstwa zawierana w innej warstwie
        :param field_names: nazwa pól z których pobierane są dane
        :param expresion: część wyrażenia wyrażenie
        :param area:minimalna powierzchnia
        :param size: minimalny rozmiar
        :return : lista obiektów
        """
        try:
            features=[]
            containing=self.mapa.warstwaRejestr(layer_containing_name)
            concluded=self.mapa.warstwaRejestr(included_layer_name)
                        
            #Naprawa warstw, konieczna bo czasem występuje błąd na difference
            #layer_containing=processing.run("native:fixgeometries", {'INPUT':containing,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #layer_concluded=processing.run("native:fixgeometries", {'INPUT':concluded,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            #Przecięcie obiektów
            # 1. Kontrola zawierania poligonu w poligonie łącznie z adresem
            collect_layer=processing.run("native:intersection", {'INPUT':concluded,'OVERLAY':containing,'INPUT_FIELDS':field_names,'OVERLAY_FIELDS':field_names,'OVERLAY_FIELDS_PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1.1 wybranie obiektów wiekszych od 2m
            extract_area=processing.run("native:extractbyexpression", {'INPUT':collect_layer,'EXPRESSION':'{} and $area>{}'.format(expresion,area),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1.2 dodanie pola Nr do połączenia warstw
            polygons_nr=processing.run("native:fieldcalculator", {'INPUT':extract_area,'FIELD_NAME':'Nr','FIELD_TYPE':1,'FIELD_LENGTH':0,'FIELD_PRECISION':0,'FORMULA':' $id ','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1.3  Utworzenie prostokątów
            bounding=processing.run("native:orientedminimumboundingbox", {'INPUT':polygons_nr,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1.4 #7 Wybór po powierzchni i szerokości
            extract=processing.run("native:extractbyexpression", {'INPUT':bounding,'EXPRESSION':'\"width\">{} and \"height\">{}'.format(size,size),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1.5 Połaczenie polygons_nr z extract 
            select=processing.run("native:joinattributestable", {'INPUT':polygons_nr,'FIELD':'Nr','INPUT_2':extract,'FIELD_2':'Nr','FIELDS_TO_COPY':[],'METHOD':1,'DISCARD_NONMATCHING':True,'PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            n=len(list(select.getFeatures()))
            
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Obiekt: ID={} nie zawiera się  w obiekcie: ID={}'.format(feat['ID'],feat['ID_2']),feat))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
                
            #2. Kontrola pokrycia przez poligon tylko geometryczna (wystawania poligonu z poligonu)
            collect_layer=processing.run("native:difference", {'INPUT':concluded,'OVERLAY':containing,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2.1 Pobranie obiektów o powierzchni>2.0
            extract_area=processing.run("native:extractbyexpression", {'INPUT':collect_layer,'EXPRESSION':'$area>{}'.format(area),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2.1 dodanie pola Nr do połączenia warstw
            polygons_nr=processing.run("native:fieldcalculator", {'INPUT':extract_area,'FIELD_NAME':'Nr','FIELD_TYPE':1,'FIELD_LENGTH':0,'FIELD_PRECISION':0,'FORMULA':' $id ','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2.2 Utworzenie prostokątów
            bounding=processing.run("native:orientedminimumboundingbox", {'INPUT':polygons_nr,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2.3 pobranie rekordów  na podstawie wyrażenia
            extract=processing.run("native:extractbyexpression", {'INPUT':bounding,'EXPRESSION':'\"width\">{} and \"height\">{}'.format(size,size),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2.4 Połaczenie polygons_nr z extract 
            select=processing.run("native:joinattributestable", {'INPUT':polygons_nr,'FIELD':'Nr','INPUT_2':extract,'FIELD_2':'Nr','FIELDS_TO_COPY':[],'METHOD':1,'DISCARD_NONMATCHING':True,'PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            n=len(list(select.getFeatures()))
            
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Obiekt: ID={} nie zawiera się  w warstwie: {}'.format(feat['ID'],layer_containing_name),feat))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
            
            
            return features
        except Exception as e:
            features.append(self.error_message(layer_containing_name,e,included_layer_name))
            return features
    
    def kontolaDuplikatow(self,pasek_wiadomosci,layer_name:str,field='ADR_BDL'):
        """Kontrola zduplikowanych wartosci
        :params pasek_wiadomosci:Pasek postepu
        :params layer_name:Nazwa warstwy
        :params field:Pole po ktorym szukane sa duplikaty
        """
        try:
            features=[]
            pasek_wiadomosci.setProgressValue(10)   
            layer=self.mapa.warstwaRejestr(layer_name)
            select=processing.run("native:extractbyexpression", {'INPUT':layer,'EXPRESSION':'count(1, "{}" )>1'.format(field),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            n=len(list(select.getFeatures()))
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Zdublowana wartość pola {}'.format(feat['{}'.format(field)]),feat))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
                
            return features
        except Exception as e:
            features.append(self.error_message(layer_name, e))
            return features
    
    def polygonSelFintersection(self,layer:QgsVectorLayer,field:str)->QgsVectorLayer:
        """"Wersja testowa eleminacj sagi nie podpięta dodać pola bo tylko geometrie przenosi

        Args:
            layer (QgsVectorLayer):Warstwa bazowa

        Raises:
            e: bląd

        Returns:
            QgsVectorLayer: Warstwa z poligonami nakladającymi się
        """
        try:
            
            test_layer = QgsVectorLayer("Polygon?crs=epsg:2180" , "test_{}".format(layer.name()), "memory")
            fields = QgsFields()
            fields.append(QgsField("Opis", QVariant.String,"String",150))           
            test_layer.dataProvider().addAttributes(fields.toList())
            test_layer.updateFields()

            features = [f for f in layer.getFeatures()]
            for n in features:
                geom = n.geometry()
                intersectList= [(geom.intersection(init.geometry()),n.getValue(field),init.getValue(field)) for init in features if geom.intersects(init.geometry())==True and n.id()!=init.id()]
                featureList=list()
                for element in intersectList:
                    feat=QgsVectorLayerUtils.createFeature(test_layer) 
                    feat.setAttribute(0,"{}->{}".format(element[1].element[2]))
                    feat.setGeometry(element[0])
                    featureList.append(feat)
                if any(featureList):
                    test_layer.dataProvider().addFeatures(featureList)
                # if any(geom.overlaps(init.geometry())==True for init in features if n.id()!=init.id()):
                #     feature=QgsFeature(n)
                #     test_layer.dataProvider().addFeature(feature)
            QgsProject.instance().addMapLayer(test_layer)
            return test_layer
        except Exception as e:
            raise e


    def kontrolujWarstwe(self,pasek_wiadomosci,layer_name:str,field='ADR_BDL',area=2.0,size=0.0010)->[]:
        """Kontrola pojedyńczej warstwy poligonowej
        :param layer_name: nazwa warstwy
        :param area: minimalna powierzchnia
        :param size: minimalny rozmiar obiektu
        :return : lista obiektów
        """
        try:
            features=[]
            pasek_wiadomosci.setProgressValue(10)            
            layer=self.mapa.warstwaRejestr(layer_name)
            #Utworzenie nowej warstwy kopii orginalnej
            layer.selectAll()
            layer_tmp=processing.run("native:saveselectedfeatures", {'INPUT': layer, 'OUTPUT': 'memory:'})['OUTPUT'] 
            layer.removeSelection()
            #Zanumerowanie ID od 1 do n poniewarz wiele warstw ma  ID=NULL lub 0
            field_idx = layer_tmp.fields().indexOf('ID')
            i=0
            layer_tmp.startEditing()
            for feat in layer_tmp.getFeatures():
                i+=1
                layer_tmp.changeAttributeValue(feat.id(), field_idx, i)
            layer_tmp.commitChanges()
            
            #
            #1 Kontrola nakładania obiektów w warstwie
            path=processing.run("saga:polygonselfintersection", {'POLYGONS':layer_tmp,'ID':field,'INTERSECT':'TEMPORARY_OUTPUT'})['INTERSECT']
            #2 Wczytanie warstwy
            intersection=QgsVectorLayer(path, "Nakladanie", "ogr")
            
            #intersection=self.polygonSelFintersection(layer,field)
            #3 Wybranie obiektów o powierzchni >2.0
            extract_area=processing.run("native:extractbyexpression", {'INPUT':intersection,'EXPRESSION':'\"ID\"=0 and $area>{}'.format(area),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #3 Naprawa warstw, konieczna bo czasem występuje błąd na orientedminimumboundingbox
            layer_repaired=processing.run("native:fixgeometries", {'INPUT':extract_area,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #4 dodanie pola Nr do połączenia warstw
            polygons_nr=processing.run("native:fieldcalculator", {'INPUT':layer_repaired,'FIELD_NAME':'Nr','FIELD_TYPE':1,'FIELD_LENGTH':0,'FIELD_PRECISION':0,'FORMULA':' $id ','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #5 Utworzenie prostokątów
            bounding=processing.run("native:orientedminimumboundingbox", {'INPUT':polygons_nr,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #6 Wybór po powierzchni i szerokości
            extract=processing.run("native:extractbyexpression", {'INPUT':bounding,'EXPRESSION':'\"width\">{} and \"height\">{}'.format(size,size),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #7 Połaczenie polygons_nr z extract 
            select=processing.run("native:joinattributestable", {'INPUT':polygons_nr,'FIELD':'Nr','INPUT_2':extract,'FIELD_2':'Nr','FIELDS_TO_COPY':[],'METHOD':1,'DISCARD_NONMATCHING':True,'PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
                        
            n=len(list(select.getFeatures()))
            
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Błąd nakładania dla obiektów {}'.format(feat['ID_1']),feat))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
            
            return features
        except Exception as e:
            #raise e
            features.append(self.error_message(layer_name, e))
            return features

    def create_report(self,heading:str,errors:[],no_data=False)->str:
        """Utworzenie raportu do zapisu
        :param heading: nagłówek
        :param errors: lista błędów
        :return raport
        """
        try:
            body='|======================================================================|\n'
            body+=heading
            body+='|=====================================================================|\n'
            if no_data==False:
                body+='| lista błędów:                                                       |\n'
            for error in errors:
                body+=' {} \n'.format(error[0])
            body+='|=====================================================================|\n\n'
            return body
        except Exception as e:
            raise e

    def utworzWarstweMemory(self,fields=QgsFields(),nazwa_warstwy="Tymczasowa", geom_type="Polygon")->QgsVectorLayer:
        """Metoda tworzy warstwę typu "memory" i dodaje ją do QgsProject"""
        
        try:
            mem_layer = QgsVectorLayer(geom_type+"?crs=epsg:2180",nazwa_warstwy,"memory")
                
            if fields==None:
                fields=QgsFields()
                fields.append(QgsField("Opis", QVariant.String,"String",80))
            
            if  fields.isEmpty():
                # definicja pol
                # dla większości kontroli pola błędu to ID, ADR_BDL, Opis.
                fields.append(QgsField("ID", QVariant.Int,"Integer",6))
                fields.append(QgsField("ADR_BDL", QVariant.String,"String",25))
                fields.append(QgsField("Opis", QVariant.String,"String",80))
    
            if mem_layer.isValid() and not fields.isEmpty():
                mem_layer.startEditing()
                mem_layer_datapr = mem_layer.dataProvider() 
                mem_layer_datapr.addAttributes(fields)
                mem_layer.commitChanges()
                
                #QgsProject.instance().addMapLayer(mem_layer)
            return mem_layer
        except Exception as e:
            raise Exception( 'Nie mozna utworzyc warstwy typu memory',e )  

    def kontrolujSzczeliny(self,pasek_wiadomosci,layer_name:str(),min_area=2.0 ,max_area=50.0,size=0.0010):
        """Kontola szczelin w warstwie
        :param pasek_wiadomosci: pasek postępu
        :param layer_name: nazwa warstwy
        :param min_area: minimalna powierzchnia szczeliny
        :param max_area: maksymalna powierzchnia szczeliny
        :param size: minimalny rozmiar szerokości i wysokości
        :return lista obiektów
        """
        try:
            features=[]
            pasek_wiadomosci.setProgressValue(10)   
            layer=self.mapa.warstwaRejestr(layer_name)
            #Naprawa warstwy
            #layer_repaired=processing.run("native:fixgeometries", {'INPUT':layer,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #1. Zasięg waratwy jako poligon, bufor 1000 metrów
            extend=processing.run("native:polygonfromlayerextent", {'INPUT':layer,'ROUND_TO':1000,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #2 Przecięcie
            difference=processing.run("native:symmetricaldifference", {'INPUT':extend,'OVERLAY':layer,'OVERLAY_FIELDS_PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #3 Rozbicie na poligony
            polygons=processing.run("native:multiparttosingleparts", {'INPUT':difference,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #4 Dodanie pola powierzchni
            polygons_area=processing.run("native:fieldcalculator", {'INPUT':polygons,'FIELD_NAME':'powierzchnia','FIELD_TYPE':0,'FIELD_LENGTH':0,'FIELD_PRECISION':0,'FORMULA':' $area ','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #5 dodanie pola Nr do połączenia warstw
            polygons_nr=processing.run("native:fieldcalculator", {'INPUT':polygons_area,'FIELD_NAME':'Nr','FIELD_TYPE':1,'FIELD_LENGTH':0,'FIELD_PRECISION':0,'FORMULA':' $id ','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #6 pobranie obiektów o powierzchni > 2.0 i mniejszej od 5000.0
            extract_area=processing.run("native:extractbyexpression", {'INPUT':polygons_nr,'EXPRESSION':'$area>{} and $area<{}'.format(min_area,max_area),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            #6 Utworzenie prostokątów
            bounding=processing.run("native:orientedminimumboundingbox", {'INPUT':extract_area,'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #7 Wybór po szerokości
            extract=processing.run("native:extractbyexpression", {'INPUT':bounding,'EXPRESSION':' \"width\" >{} and \"height\">{}'.format(size,size),'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            #8 Połaczenie polygons_nr z extract 
            select=processing.run("native:joinattributestable", {'INPUT':extract_area,'FIELD':'Nr','INPUT_2':extract,'FIELD_2':'Nr','FIELDS_TO_COPY':[],'METHOD':1,'DISCARD_NONMATCHING':True,'PREFIX':'','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            
            n=len(list(select.getFeatures()))
            
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Ostrzeżenie - szczelina geometryczna. Powierzchnia:{} m2'.format(round(feat['powierzchnia'],2)),feat))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
            
            return features
        except Exception as e:
            features.append(self.error_message(layer_name, e))
            return features
    
    def kontrolaPodstawowaTask(self,task:QgsTask,layer_name:str):
        """Kontrola podstawowa warstwy przy pomocy qgis:checkvalidity i task
        :params task:task
        :params layer_name:nazwa warstwy
        :return nazwa warstwy błędnej lub None
        """
        try:
            layer=self.getLayerToFile(layer_name)
            error_layer=processing.run("qgis:checkvalidity", {'INPUT_LAYER':layer,'METHOD':2,'IGNORE_RING_SELF_INTERSECTION':False,'VALID_OUTPUT':'TEMPORARY_OUTPUT','INVALID_OUTPUT':'TEMPORARY_OUTPUT','ERROR_OUTPUT':'TEMPORARY_OUTPUT'})['INVALID_OUTPUT']
            if len(list(error_layer.getFeatures()))>0:
                return layer_name
            return None
        except Exception as e:
            raise e
    
    def kontrolaPodstawowa(self,pasek,layer_name:str()):
        """Kontrola podstawowa warstwy przy pomocy qgis:checkvalidity
        :params pasek:pasek postępu
        :params layer_name:nazwa warstwy
        :return nazwa warstwy błędnej lub None
        """
        try:
            layer=self.mapa.warstwaRejestr(layer_name)
            pasek.setText('Kontrola podstawowa warstwy {}'.format(layer_name))
            error_layer=processing.run("qgis:checkvalidity", {'INPUT_LAYER':layer,'METHOD':2,'IGNORE_RING_SELF_INTERSECTION':False,'VALID_OUTPUT':'TEMPORARY_OUTPUT','INVALID_OUTPUT':'TEMPORARY_OUTPUT','ERROR_OUTPUT':'TEMPORARY_OUTPUT'})['INVALID_OUTPUT']
            if len(list(error_layer.getFeatures()))>0:
                return layer_name
            return None
        except Exception as e:
            raise e
    
    def getLayerToFile(self,layer_name:str()):
        """Zwraca obiekt warstwy z pliku
        :params path:ścierzka do pliku
        """
        try:
            path='{}\{}.shp'.format(self.konfiguracja.warstwy,layer_name)
            return QgsVectorLayer(path, "Test", "ogr")
        except Exception as e:
            raise e

    def  create_fill_layer(self,errors:[],map:{},fields=QgsFields(),layre_name="Tymczasowa",short_name="error_log_mapa_pu" ,geom_type="Polygon")->QgsVectorLayer:
        """Tworzy i wypełnia warstwę z błędami
        :param errors: lista błędów
        :param map: mapowanie błędu na warstwę
        :fields: lista pól warstwy błędów
        :param layer_name: nazwa warstwy
        :param geom_type: typ warstwy
        :return : tymczasowa warstwa z błędami 
        """
        try:
            #Dla braku błędu nie tworzymy warstwy
            if len(errors)==0:
                return None
            if errors[0][1]==None:
            #Dla błędu kontroli warstwy 
                return None
            layer=self.utworzWarstweMemory(fields,nazwa_warstwy=layre_name,geom_type=geom_type)
            layer.setShortName(short_name)
            #Tworzenie obiektów błedów i dodanie do warstwy
            for error in errors:
                if error[1]==None:
                    continue
                feat=QgsFeature(layer.fields())
                for field in layer.fields():
                    if field.name()==u"Opis":
                         feat.setAttribute('Opis',error[0])
                    else:
                        feat.setAttribute(field.name(),error[1][map[field.name()]])
                feat.setGeometry(error[1].geometry())
                layer.dataProvider().addFeature(feat)
            
            return layer
        except Exception as e:
            raise e

    def napraw_warstwe(self,layer_name:str()):
        """Naprawa warstwy i zapisanie w orginalnej lokalizacji
        :params layer_name:nazwa warstwy
        """
        try:
            #Sprawdzenie katalogu tmp i utworzenie
            if os.path.isdir(self.konfiguracja.tmp)==False:
                self.projekt.utworzKatalog(self.konfiguracja.tmp)
            layer=self.mapa.warstwaRejestr(layer_name)
            #path_delete=layer.source()
            path='{}//{}.shp'.format(self.konfiguracja.tmp,layer_name)
            ret=processing.run("native:fixgeometries", {'INPUT':layer,'OUTPUT':path})
            
        except Exception as e:
            raise e
    
    def kontrolaPodstawowaCompleted(self,exception,result):
        """Metoda końcowa kontroli podstawowwej
        :params exception: błąd
        :params result: wynik przetwarzania
        """
        if exception is None:
            if result is not None:
                self.layer_names.append(result)
        else:
            raise exception
    
    def kontrolePodstawoweTask(self,pasek):
        """Podstawowa kontrola sprawdzenie czy geometrie w warstwach nie są błedne. Do dalszych wymagane są poprawne geometrie.
        Użytkownik podejmuje decyzję czy automatycznie naprawiać geometrie
        :params pasek: pasek postępu
        :return czy geometrie są błędne czy naprawione
        """ 
        try:
            pasek.setText('Kontrola podstawowa')
            self.layer_names=[]
            #'O_PODST'
            task1=QgsTask.fromFunction('Waste cpu 1', self.kontrolaPodstawowaTask,on_finished=self.kontrolaPodstawowaCompleted, layer_name='O_PODST')
            QgsApplication.taskManager().addTask(task1)
            #layer_names.append(self.kontrolaPodstawowa(pasek,'O_PODST'))
            #'POW'
            return True
            layer_names.append(self.kontrolaPodstawowa(pasek,'POW'))
            #'ODDZIAL'
            layer_names.append(self.kontrolaPodstawowa(pasek,'ODDZIAL'))
            #'PNSW'
            layer_names.append(self.kontrolaPodstawowa(pasek,'PNSW'))
            #'DZ_EWID'
            layer_names.append(self.kontrolaPodstawowa(pasek,'DZ_EWID'))
            #'UZYTKI'
            layer_names.append(self.kontrolaPodstawowa(pasek,'UZYTKI'))
            #'OS_PKT'
            layer_names.append(self.kontrolaPodstawowa(pasek,'OS_PKT'))
            #'OP_POW'
            layer_names.append(self.kontrolaPodstawowa(pasek,'OP_POW'))
            #'OP_ODDZ'
            layer_names.append(self.kontrolaPodstawowa(pasek,'OP_ODDZ'))
            #'OS_POW'
            layer_names.append(self.kontrolaPodstawowa(pasek,'OS_POW'))
            
            #errors=list(filter(None, layer_names))
            if len(errors)>0:
                ret=komunikaty.pytanie_tak_nie("Błędna geometria",'Program wykrył błędne geometrie dla warstw:\n{}\nW celu wykonania kontroli konieczna jest naprawa geometrii.\nCzy program ma naprawić warstwy z błędną geometrią?'.format(',\n'.join(errors)))
                if ret == 0:
                    #Naprawa geometrii
                    [self.napraw_warstwe(layer_name) for layer_name in errors]
                    #Zamknięcie projektu
                    self.mapa.wyczyscProjekt()
                    #Przeniesienie plików z Tmp do Warstw
                    [self.projekt.przenies_plik('{}\\{}'.format(self.konfiguracja.tmp,file),'{}\\{}'.format(self.konfiguracja.warstwy,file)) for file in os.listdir(self.konfiguracja.tmp)]
                    #Wczytanie projektu
                    self.mapa.otworzProjekt()
                    return True
                else:
                    #Rezygnacja z kontroli
                    return False
            else:
                return True
        except Exception as e:
            raise e    
    
    def kontrola_podstawowa(self,pasek)->bool:
        """Podstawowa kontrola sprawdzenie czy geometrie w warstwach nie są błedne. Do dalszych wymagane są poprawne geometrie.
        Użytkownik podejmuje decyzję czy automatycznie naprawiać geometrie
        :params pasek: pasek postępu
        :return czy geometrie są błędne czy naprawione
        """ 
        try:
            pasek.setText('Kontrola podstawowa')
            layer_names=[]
            if self.__kontrole['KP_O_PODST'].wykonaj:
                #'O_PODST'
                layer_names.append(self.kontrolaPodstawowa(pasek,'O_PODST'))
            if self.__kontrole['KP_POW'].wykonaj:
                #'POW'
                layer_names.append(self.kontrolaPodstawowa(pasek,'POW'))
            if self.__kontrole['KP_ODDZIAL'].wykonaj:
                #'ODDZIAL'
                layer_names.append(self.kontrolaPodstawowa(pasek,'ODDZIAL'))
            if self.__kontrole['KP_PNSW'].wykonaj:
                #'PNSW'
                layer_names.append(self.kontrolaPodstawowa(pasek,'PNSW'))
            if self.__kontrole['KP_DZ_EWID'].wykonaj:
                #'DZ_EWID'
                layer_names.append(self.kontrolaPodstawowa(pasek,'DZ_EWID'))
            if self.__kontrole['KP_UZYTKI'].wykonaj:
                #'UZYTKI'
                layer_names.append(self.kontrolaPodstawowa(pasek,'UZYTKI'))
            if self.__kontrole['KP_OS_PKT'].wykonaj:
                #'OS_PKT'
                layer_names.append(self.kontrolaPodstawowa(pasek,'OS_PKT'))
            if self.__kontrole['KP_OP_POW'].wykonaj:
                #'OP_POW'
                layer_names.append(self.kontrolaPodstawowa(pasek,'OP_POW'))
            if self.__kontrole['KP_OP_ODDZ'].wykonaj:
                #'OP_ODDZ'
                layer_names.append(self.kontrolaPodstawowa(pasek,'OP_ODDZ'))
            if self.__kontrole['KP_OS_POW'].wykonaj:
                #'OS_POW'
                layer_names.append(self.kontrolaPodstawowa(pasek,'OS_POW'))
            errors=list(filter(None, layer_names))
            if len(errors)>0:
                ret=komunikaty.pytanie_tak_nie("Błędna geometria",'Program wykrył błędne geometrie dla warstw:\n{}\nW celu wykonania kontroli konieczna jest naprawa geometrii.\nCzy program ma naprawić warstwy z błędną geometrią?'.format(',\n'.join(errors)))
                if ret == 0:
                    #Naprawa geometrii
                    [self.napraw_warstwe(layer_name) for layer_name in errors]
                    #Zamknięcie projektu
                    self.mapa.wyczyscProjekt()
                    #Przeniesienie plików z Tmp do Warstw
                    [self.projekt.przenies_plik('{}\\{}'.format(self.konfiguracja.tmp,file),'{}\\{}'.format(self.konfiguracja.warstwy,file)) for file in os.listdir(self.konfiguracja.tmp)]
                    #Wczytanie projektu
                    self.mapa.otworzProjekt()
                    return True
                else:
                    #Rezygnacja z kontroli
                    return False
            else:
                return True
        except Exception as e:
            raise e    
    
    def kontrolaGeometriiNULL(self,pasek_wiadomosci,layer_name:str()):
        """Wybranie geometri o wartości NULL
        :params pasek_wiadomosci:Pasek postępu
        :params layer_name:Nazwa warstwy
        """
        try:
            features=[]
            pasek_wiadomosci.setProgressValue(10)   
            layer=self.mapa.warstwaRejestr(layer_name)
            #Wybrnie geometrii NULL
            select=processing.run("native:extractbyexpression", {'INPUT':layer,'EXPRESSION':'$geometry IS NULL','OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']
            
            n=len(list(select.getFeatures()))
            
            k=0
            for feat in select.getFeatures():
                k+=1                
                features.append(('Obiekt: ID={} nie posiada geometrii'.format(feat['ID']),featl))
                pasek_wiadomosci.setProgressValue((k / float(n if n>0 else 1))*100)
            
            return features
        except Exception as e:
            features.append(self.error_message(layer_name, e))
            return features
                  
    def kontrola_ukladu_warstwy(self,pasek_wiadomosci,layer_name:str):
        """Kontroluje czy warstwa jest w układzie EPSG:2180
        :params pasek_wiadomosci:Pasek postępu
        :params layer_name:Nazwa warstwy
        """
        try:
            features=[]
            pasek_wiadomosci.setProgressValue(10)   
            layer=self.mapa.warstwaRejestr(layer_name)
            #Kontrola układu warstwy
            crs=layer.crs()
            if crs.authid() not in 'EPSG:2180':#'ETRF2000-PL / CS92':
                features.append(('Warstwa: {} ma układ {} inny niż "EPSG:2180" wymagany przez Mapa PU'.format(layer_name,crs.authid()),None))
            return features
        except Exception as e:
            features.append(self.error_message(layer_name, e))
            return features
            
    def kontrola_liczby_obiektow(self,names):
        """Kontroluje czy warstwy nie są puste
        :params layer_name:Nazwa warstwy
        :params layer_name_2:Nazwa warstwy
        """
        try:
            features=[]
            if type(names) is list:
                for name in names:
                    layer=self.mapa.warstwaRejestr(name)
                    count=len(list(layer.getFeatures()))
                    if count==0:
                        features.append(('Warstwa {} jest pusta, nie wykonano kontroli.'.format(name),None))
            else:
                layer=self.mapa.warstwaRejestr(names)
                count=len(list(layer.getFeatures()))
                if count==0:
                    features.append(('Warstwa {} jest pusta, nie wykonano kontroli.'.format(names),None))
            return features
        
        except Exception as e:
            features.append(self.error_message(','.join(names) if type(names) is list else names,e))
            return features         
            
    def error_message(self,layer_name:str,e,layer_name_1=None)->():
        """Tekst obsługi błędu
        :params layer_name:Nazwa warstwy
        """
        if layer_name_1==None:
            return ('Warstwa {} jest nieprawidłowa i nie można przeprowadzić kontroli\n Błąd: {}'.format(layer_name,e),None)  
        else:
            return ('Warstwa {} lub {} jest nieprawidłowa i nie można przeprowadzić kontroli\n Błąd: {}'.format(layer_name,layer_name_1,e),None)
    
    def start(self):
        try:
            
#             from datetime import datetime
#             start=datetime.now()
            errorsExcel=[]
            pasek=PasekWiadomosc(self.iface,u'Kontrola geometrii')
            pasek.pasekPostepu()
            report=''
            layers=[]
            layer_names=[]
            #Kontrola podstawowa poprawności warstw
            ret=self.kontrola_podstawowa(pasek)
            if ret==False:
                return
            report+='Kontrole geometryczne\nWersja programu Mapa PU {}\n'.format(self.__wersja)
            
            #Kontrole duplikatów
            heading='Kontrola zdublowanych wartości'
            if self.__kontrole['KD_OP_POW'].wykonaj:
                #OP_POW
                name='OP_POW'
                
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontolaDuplikatow(pasek,name,'ADR_BDL')
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='Kontrola duplikatów {}'.format(name),geom_type="Point")
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    #Usuniecie zduplikowanych komunikatów
                    errors=[(key,) for key,_ in itertools.groupby(errors, lambda x:x[0] )]
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
                    
            if self.__kontrole['KD_OP_ODDZ'].wykonaj:
                #OP_POW
                name='OP_ODDZ'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontolaDuplikatow(pasek,name,'ADR_BDL')
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='Kontrola duplikatów {}'.format(name),geom_type="Point")
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    #Usuniecie zduplikowanych komunikatów
                    errors=[(key,) for key,_ in itertools.groupby(errors, lambda x:x[0] )]
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            #Kontrole układów warstw
            heading='Kontrola zgodności układu warstwy'
            if self.__kontrole['KU_DZ_EWID'].wykonaj:
                #DZ_EWID
                name='DZ_EWID'
                errors=self.kontrola_liczby_obiektow(name)
                #Kontrola czy warstwa ma obiekty
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,no_data=True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_LINIE'].wykonaj:
                #LINIE
                name='LINIE'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_O_PODST'].wykonaj:
                #O_PODST
                name='O_PODST'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_ODDZIAL'].wykonaj:
                #ODDZIAL
                name='ODDZIAL'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_OP_ODDZ'].wykonaj:
                #OP_ODDZ
                name='OP_ODDZ'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_OP_POW'].wykonaj:
                #OP_POW
                name='OP_POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_OS_PKT'].wykonaj:
                #OS_PKT
                name='OS_PKT'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_OS_POW'].wykonaj:
                #OS_POW
                name='OS_POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_PNSW'].wykonaj:
                #PNSW
                name='PNSW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_POW'].wykonaj:
                #POW
                name='POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KU_UZYTKI'].wykonaj:
                #UZYTKI
                name='UZYTKI'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrola_ukladu_warstwy(pasek, '{}'.format(name))
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            #Kontrole geometrii NULL
            heading='Kontrola braku geometrii'
            if self.__kontrole['KNULL_DZ_EWID'].wykonaj:
                #DZ_EWID
                name='DZ_EWID'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KNULL_LINIE'].wykonaj: 
                #LINIE
                name='LINIE'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
                    #
            
            if self.__kontrole['KNULL_O_PODST'].wykonaj:  
                #O_PODST
                name='O_PODST'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
             
            if self.__kontrole['KNULL_ODDZIAL'].wykonaj: 
                #ODDZIAL
                name='ODDZIAL'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]            
            
            if self.__kontrole['KNULL_OP_ODDZ'].wykonaj: 
                #OP_ODDZ
                name='OP_ODDZ'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KNULL_OP_POW'].wykonaj:             
                #OP_POW
                name='OP_POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else: 
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]            
            
            if self.__kontrole['KNULL_OS_PKT'].wykonaj:             
                #OS_PKT
                name='OS_PKT'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KNULL_OS_POW'].wykonaj: 
                #OS_POW
                name='OS_POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
             
            if self.__kontrole['KNULL_PNSW'].wykonaj: 
                #PNSW
                name='PNSW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
             
            if self.__kontrole['KNULL_POW'].wykonaj: 
                #POW
                name='POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
             
            if self.__kontrole['KNULL_UZYTKI'].wykonaj: 
                #UZYTKI
                name='UZYTKI'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolaGeometriiNULL(pasek, '{}'.format(name))
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
                      
            
            #Kontrole warstwy
            heading='Kontrola nałożeń'
            if self.__kontrole['KN_O_PODST'].wykonaj:
                #'O_PODST'
                name='O_PODST'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors,True)
                else:
                    pasek.setText('{} {}'.format(heading,name))
                    errors=self.kontrolujWarstwe(pasek,'{}'.format(name))
                    map={}#map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='{} {}'.format(heading,name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  {} {} \n'.format(heading,name), errors)
                    [errorsExcel.append(ExcelError(u'{} {}'.format(heading,name),error[0])) for error in errors]
            
            if self.__kontrole['KN_POW'].wykonaj:
                #'POW'
                name='POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola nałożeń {}'.format(name))
                    errors=self.kontrolujWarstwe(pasek,'{}'.format(name))
                    map={}#map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='Kontrola nałożeń {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola nałożeń {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KN_ODDZIAL'].wykonaj:
                #'ODDZIAL'
                name='ODDZIAL'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola nałożeń {}'.format(name))
                    errors=self.kontrolujWarstwe(pasek,'{}'.format(name))
                    map={}#map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola nałożeń {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola nałożeń {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KN_PNSW'].wykonaj:
                #'PNSW'
                name='PNSW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola nałożeń {}'.format(name))
                    errors=self.kontrolujWarstwe(pasek,'{}'.format(name))
                    map={}#map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola nałożeń {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola nałożeń {}'.format(name),error[0])) for error in errors]
            
            #DZ_EWID
            #Zgłoszenie https://buligl.atlassian.net/browse/MPU-18
#             name='DZ_EWID'
#             pasek.setText('Kontrola nałożeń {}'.format(name))
#             errors=self.kontrolujWarstwe(pasek,'{}'.format(name),'ID')
#             map={}#map={'ID':'ID','ADR_BDL':'ADR_ADM'}
#             layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola nałożeń {}'.format(name))
#             #dodanie warstwy błędów
#             layers.append(layer)
#             #dodanie do pliku tekstowego błędów
#             report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors)
            
            #'UZYTKI'
            #Zgłoszenie https://buligl.atlassian.net/browse/MPU-18
#             name='UZYTKI'
#             pasek.setText('Kontrola nałożeń {}'.format(name))
#             errors=self.kontrolujWarstwe(pasek,'{}'.format(name),'ID')
#             map={}#map={'ID':'ID','ADR_BDL':'ADR_ADM'}
#             layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola nałożeń {}'.format(name))
#             #dodanie warstwy błędów
#             layers.append(layer)
#             #dodanie do pliku tekstowego błędów
#             report+=self.create_report(u'  Kontrola nałożeń {} \n'.format(name), errors)
            
            
            #Zawierania warstw punktowych
            if self.__kontrole['KZW_POW_OS_PKT'].wykonaj:
                names=['POW','OS_PKT']
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #Kontrola zawierania OS_PKT -->> POW
                    errors=self.zawieranieWarstwPkt(names[0],names[1], '"ADR_BDL"!="ADR_BDL_2" or "distance">0','Opis: ID={} nie leży  w pododdziale: ID={}')
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),geom_type="Point")
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
            
            if self.__kontrole['KZW_POW_OP_POW'].wykonaj: 
                names=['POW','OP_POW'] 
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #Kontrola zawierania OP_POW -->> POW
                    errors=self.zawieranieWarstwPkt(names[0],names[1], '"ADR_BDL"!="ADR_BDL_2" or "distance">0','Opis: ID={} nie leży  w pododdziale: ID={}')
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),geom_type="Point")
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
             
            if self.__kontrole['KZW_ODDZIAL_OP_ODDZ'].wykonaj: 
                names=['ODDZIAL','OP_ODDZ']
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPkt(names[0],names[1], '"ADR_BDL"!="ADR_BDL_2" or "distance">0','Opis: ID={} nie leży  w pododdziale: ID={}')
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    #dodanie warstwy błędów
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),geom_type="Point")
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
             
            if self.__kontrole['KZW_ODDZIAL_POW'].wykonaj: 
                #Zawieranie warstw poligonowych
                names=['ODDZIAL', 'POW']
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1], ['ID','ADR_BDL'], 'substr("ADR_BDL" ,0,18)!=substr("ADR_BDL_2" ,0,18)') 
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
                
            if self.__kontrole['KZW_DZ_EWID_UZYTKI'].wykonaj:    
                names=['DZ_EWID','UZYTKI']    
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1],['ID',"ADR_ADM","NR_EW"], '(trim("ADR_ADM") != trim("ADR_ADM_2") or  trim("NR_EW") != trim("NR_EW_2")) ')
                    map={'ID':'ID','ADR_BDL':'ADR_ADM'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
            
            if self.__kontrole['KZW_POW_PNSW'].wykonaj:    
                names=['POW','PNSW']
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1],['ID','ADR_BDL'],'trim("ADR_BDL")  != trim("ADR_BDL_2") ')
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
            
            if self.__kontrole['KZW_POW_OS_POW'].wykonaj:   
                names=['POW','OS_POW']  
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                     report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1],['ID','ADR_BDL'],'trim("ADR_BDL")  !=trim("ADR_BDL_2") ')
                    map={'ID':'ID','ADR_BDL':'ADR_BDL'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
               
            if self.__kontrole['KZW_UZYTKI_O_PODST'].wykonaj:   
                names=['UZYTKI','O_PODST']   
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors,True)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1],['ID','ADR_ADM','NR_EW','NR_KONT'],'(trim("ADR_ADM")  != trim("ADR_ADM_2") or trim("NR_EW")!= trim("NR_EW_2") or "NR_KONT"!= "NR_KONT_2") ')
                    map={'ID':'ID','ADR_BDL':'ADR_ADM'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
 
                           
            if self.__kontrole['KZW_DZ_EWID_O_PODST'].wykonaj:   
                names=['DZ_EWID','O_PODST']   
                errors=self.kontrola_liczby_obiektow(names)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                else:
                    pasek.setText('Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #'Kontrola zawierania warstw O_PODST -->> UZYTKI'
                    errors=self.zawieranieWarstwPoligonowych(pasek,names[0],names[1],['ID',"ADR_ADM","NR_EW"],'(trim("ADR_ADM")!= trim("ADR_ADM_2") or trim("NR_EW") != trim("NR_EW_2")) ')
                    map={'ID':'ID','ADR_BDL':'ADR_ADM'}
                    layer=self.create_fill_layer(errors,map , layre_name='Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola zawierania warstw {} -->> {} \n'.format(names[1],names[0]), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola zawierania warstw {} -->> {}'.format(names[1],names[0]),error[0])) for error in errors]
           
            #Kontrola szczelin
            if self.__kontrole['KS_O_PODST'].wykonaj:   
                #'O_PODST'
                name='O_PODST'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola szczelin  {}'.format(name))
                    errors=self.kontrolujSzczeliny(pasek,name)
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None ,layre_name='Kontrola szczelin {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola szczelin  {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KS_POW'].wykonaj: 
                #'POW'
                name='POW'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola szczelin  {}'.format(name))
                    errors=self.kontrolujSzczeliny(pasek,name)
                    map={}
                    layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola szczelin {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola szczelin  {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KS_ODDZIAL'].wykonaj: 
                #'ODDZIAL'
                name='ODDZIAL'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola szczelin  {}'.format(name))
                    errors=self.kontrolujSzczeliny(pasek,name)
                    map={}
                    layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola szczelin {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola szczelin  {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KS_DZ_EWID'].wykonaj: 
                #'DZ_EWID'
                name='DZ_EWID'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola szczelin  {}'.format(name))
                    errors=self.kontrolujSzczeliny(pasek,name)
                    map={}
                    layer=self.create_fill_layer(errors,map ,fields=None , layre_name='Kontrola szczelin {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola szczelin  {}'.format(name),error[0])) for error in errors]
            
            if self.__kontrole['KS_UZYTKI'].wykonaj: 
                #'UZYTKI'
                name='UZYTKI'
                errors=self.kontrola_liczby_obiektow(name)
                if len(errors)>0:
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors,True)
                else:
                    pasek.setText('Kontrola szczelin  {}'.format(name))
                    errors=self.kontrolujSzczeliny(pasek,name)
                    map={}
                    layer=self.create_fill_layer(errors,map,fields=None , layre_name='Kontrola szczelin {}'.format(name))
                    #dodanie warstwy błędów
                    layers.append(layer)
                    #dodanie do pliku tekstowego błędów
                    report+=self.create_report(u'  Kontrola szczelin  {} \n'.format(name), errors)
                    [errorsExcel.append(ExcelError(u'Kontrola szczelin  {}'.format(name),error[0])) for error in errors]
            
            self.zapisz(layers, report,errorsExcel)

            
        except Exception as e:
            raise e
        
    def zapisz(self,layers,report,errorsExcel):
        heading=('Kontrole geometryczne','Wersja programu Mapa PU {}, {}'.format(self.__wersja,date_helper.curentDate()),'Raport zawiera wyniki kontroli geometrycznych.')
        self.mapa.usunWarstwyMemory()
        filename_xls='%s\kontrola_geometryczna__%s.xlsx' % (self.konfiguracja.kontrole,  datetime.date.today())
        [QgsProject.instance().addMapLayer(layer) for layer in layers] 
        zapiszText(self._log_sciezka, report )
        #Zapis do pliku excel
        
        excel=Excel()
        excel.save_to_excell(errorsExcel, self.__root, filename_xls,heading)
        
        self._ret = komunikaty.pytanie_zamknij_pokaz_raport_txt_xls(u'Zakończenie kontroli ', (u"Zakończono kontrolę poprawności geometrycznej warstw.  Szczegóły zostały zapisane do pliku raportu \n '%s'" % '{}\n{}'.format(self._log_sciezka,filename_xls)))
        if self._ret == 1 :
            os.startfile(self._log_sciezka)
        if self._ret == 2 :
            os.startfile(filename_xls)
            