feature (wip): první krůčky logiky pro parsování PAS záznamů

- dosavadní logika parsování platná pro akce a lokality je podmíněna typ_dat
- stub logiky parsování pro samostatné nálezy

.github/pull_request_template.md

@@ -0,0 +1,35 @@
+<!--
+Děkujeme za příspěvek! Vyplň prosím sekce níže.
+Nepotřebné body můžeš smazat. Komentáře (<!-- ... -->) se v PR nezobrazují.
+-->
+
+## Souhrn
+
+<!-- Stručně co a proč. 1–3 věty. -->
+
+## Změny
+
+<!-- Co se konkrétně mění, ideálně po souborech / oblastech. -->
+-
+
+## Testování
+
+<!-- Jak ověřit, že to funguje (kroky v QGIS, scénáře). -->
+-
+
+## Zapojení AI
+
+<!-- Byla u změny použita AI? Jak? Např. "text navržen AI, ručně zkontrolováno
+     a upraveno". Smaž, pokud AI použita nebyla. -->
+-
+
+## Kontrolní seznam
+- [ ] Změny jsou v souladu se stylem projektu (viz `AGENTS.md`)
+- [ ] Při změně funkcí povýšena verze v `amcr_viewer/metadata.txt` a doplněn `changelog`
+- [ ] Otestováno v QGIS (min. podporovaná verze 3.44)
+- [ ] PR míří do správné cílové větve
+- [ ] Větev odpovídá konvenci (`feat/ fix/ docs/ chore/<téma>`, AI `agents/<jméno>/<téma>`)
+
+## Související issue
+
+<!-- Např. "Closes #123". Smaž, pokud se neváže k issue. -->

AGENTS.md

@@ -0,0 +1,122 @@
+# AGENTS.md
+
+Pokyny pro AI agenty i lidské přispěvatele pracující v tomto repozitáři.
+Tento soubor je jediný zdroj pravdy; `CLAUDE.md` na něj pouze odkazuje.
+
+## O projektu
+
+**AMČR Viewer** je plugin do QGIS pro stahování a vizualizaci dat z Digitálního
+archivu Archeologické mapy ČR (AMČR / AIS CR) – akce (*Fieldwork events*),
+lokality (*Sites*) a jejich komponenty. Podporuje anonymní i přihlášený přístup
+přes AMČR účet.
+
+Zdroj dat: https://digiarchiv.aiscr.cz/ · Nápověda: https://amcr-help.aiscr.cz/digiarchiv/qgis-viewer.html
+
+## Zařazení v ekosystému AIS CR
+
+Tento repozitář je jedním ze **sourozeneckých repozitářů** ekosystému AIS CR.
+Centrální governance a AI konfigurace spravuje hub **`aiscr-management`**; konvence
+v tomto souboru jsou s tímto vzorem sladěné a zjednodušené pro potřeby jednoho
+QGIS pluginu. Těžkou mašinerii hubu (složka `.agents/`, OpenSpec, sync skripty,
+multi-assistant generování) tento repozitář **záměrně nepřebírá**. Při širších
+otázkách governance má přednost vzor z `aiscr-management`.
+
+## Struktura repozitáře
+
+```
+amcr_viewer/            # vlastní kód pluginu (toto se balí do releasu)
+  amcr_viewer.py        # vstupní bod pluginu, integrace do QGIS
+  amcr_dialog.py        # dialogy a UI (filtry, přihlášení)
+  amcr_tools.py         # stahování dat z API, sestavení vrstev a atributů
+  amcr_codelists.py     # hesláře / číselníky (codelists)
+  codelists/heslar.csv  # lokální kopie číselníků
+  metadata.txt          # metadata pluginu + verze + changelog
+  i18n/                 # překlady (.ts)
+  *.png                 # ikony
+.github/workflows/      # CI – release pluginu
+README.md               # uživatelská dokumentace (anglicky)
+```
+
+## Konvence
+
+### Jazyk
+- **Kód a identifikátory:** anglicky. Atributová pole vrstev musí být ASCII
+  kompatibilní (bez diakritiky) – viz historie změn v `metadata.txt`.
+- **README a uživatelská dokumentace:** anglicky.
+- **Commity, PR a komentáře v issue:** česky.
+
+### Commity
+- Styl odpovídá historii: česky, věcně, popisně; jeden commit = jedna logická
+  změna.
+- První řádek stručně a výstižně (ideálně v imperativu); podrobnosti do těla.
+- Pokud je commit připraven s pomocí AI, uveď to v těle commitu nebo v popisu PR.
+
+### Větve
+Konvence názvů je sladěná s hubem `aiscr-management`:
+
+- **lidé:** `feat/<téma>` (nová funkce), `fix/<téma>` (oprava), `docs/<téma>`
+  (dokumentace), `chore/<téma>` (údržba).
+- **AI agenti:** `agents/<jméno-agenta>/<téma>` (např. `agents/claude/oprava-pian`).
+
+Další pravidla:
+
+- Cílová větev pro nový vývoj je aktuální `version/v2.x.y` (ne přímo do
+  výchozí větve bez PR).
+- **Nikdy** nepushuj přímo do chráněných větví; vždy přes Pull Request.
+- Standardizační / nefunkční změny drž v samostatné větvi, ať se nemíchají do
+  feature PR.
+
+### Pravidla pro AI agenty (git)
+- AI ve výchozím stavu zůstává u **lokální práce na aktuální větvi**.
+- Bez **výslovného pokynu** uživatele AI nestageuje (`git add`), necommituje,
+  nepushuje ani samo nepřepíná/nezakládá větev pro vzdálené doručení.
+- Při výslovném požadavku na push/PR použij větev `agents/<jméno-agenta>/<téma>`;
+  pokud aktuální větev tomuto vzoru neodpovídá, vyžádej si nejdřív potvrzení.
+- Vytvoření větve, stage, commit, push ani draft PR AI běžně nenabízí; zmiňuj je
+  jen tehdy, když jsou pro splnění úkolu opravdu nutné.
+
+### QGIS specifika
+- Minimální podporovaná verze QGIS je **3.44** (`qgisMinimumVersion` v
+  `metadata.txt`); kód nesmí spoléhat na novější API.
+- Vrstvy a atributy se sestavují přes `QgsField` / QGIS API v `amcr_tools.py`.
+  Při přidání atributu je potřeba doplnit ho konzistentně na všech místech:
+  definice pole (`QgsField`), naplnění hodnoty z dokumentu, překlad hlavičky
+  sloupce a export atributů.
+
+## Verzování a release
+
+- Verze pluginu žije v **`amcr_viewer/metadata.txt`** (`version=`).
+- **Při každé změně chování / nové funkci** povyš verzi a doplň položku do
+  `changelog=` v `metadata.txt` (formát `vX.Y.Z (RRRR-MM-DD)` + odrážky).
+- Datum v changelogu ber z **deterministického zdroje**, ne z paměti, např.
+  `python -c "import datetime; print(datetime.date.today().isoformat())"`.
+- Release se vytváří publikací GitHub Release; workflow
+  `.github/workflows/release_plugin.yml` zabalí složku `amcr_viewer/` do
+  `amcr_viewer.zip` a přiloží ji k releasu. Do ZIPu se nesmí dostat `.git*`
+  soubory.
+
+## Pull requesty
+
+- Používej PR šablonu (`.github/pull_request_template.md`): Souhrn / Změny /
+  Testování / Kontrolní seznam.
+- PR musí mířit do správné `version/v2.x.y` větve.
+- Před požádáním o review projdi kontrolní seznam v šabloně (zejména bump verze
+  v `metadata.txt`, pokud měníš chování).
+- V popisu PR uveď **podíl AI** (např. „text navržen AI, ručně zkontrolováno")
+  a odkaz na související issue, pokud existuje.
+
+## Bezpečnost a soukromí
+
+- Do promptů, příkladů ani commitů **nevkládej** ostrá produkční data, plné
+  log dumpy ani reálné osobní údaje (PII).
+- **Rediguj** secrets, tokeny, API klíče a hesla z čehokoli, co posíláš AI;
+  nikdy je necommituj do repozitáře (ani přihlašovací údaje k AMČR účtu).
+- Pro interní infrastrukturu (URL, hostname, prostředí) používej placeholdery,
+  pokud konkrétní hodnota není nutná a povolená.
+
+## Lokální ověření
+
+Plugin se testuje načtením do QGIS (Plugins → Manage and Install Plugins →
+Install from ZIP, nebo nasazením složky `amcr_viewer/` do adresáře pluginů
+QGIS). Automatizované testy zatím repozitář neobsahuje – změny ověřuj ručně
+v QGIS na podporované verzi.

CLAUDE.md

@@ -0,0 +1,6 @@
+# CLAUDE.md
+
+Pokyny pro tento repozitář jsou v [`AGENTS.md`](./AGENTS.md).
+
+Tento soubor je záměrně jen odkaz, aby existoval jeden zdroj pravdy a obsah se
+nerozjel. Cokoli platí pro AI agenty v tomto projektu, najdeš v `AGENTS.md`.

amcr_viewer/amcr_codelists.py

@@ -9,24 +9,30 @@ from qgis.core import QgsMessageLog, Qgis
 # Define paths for the plugin and its codelists directory
 PLUGIN_DIR = os.path.dirname(__file__)
 CODELISTS_DIR = os.path.join(PLUGIN_DIR, 'codelists')
-BASE_URL = "https://api.aiscr.cz/2.2/oai"
+BASE_URL_AMCR = "https://api.aiscr.cz/2.2/oai"
+BASE_URL_DA = "https://digiarchiv.aiscr.cz/api/search/query"
 OUTPUT_FILE = os.path.join(CODELISTS_DIR, 'heslar.csv')
 
 slovnicek = {
-    'obdobi': 'heslo:obdobi',
+    'obdobi': (BASE_URL_AMCR, 'heslo:obdobi'),
-    'typ_akce': 'heslo:akce_typ',
+    'typ_akce': (BASE_URL_AMCR, 'heslo:akce_typ'),
-    'areal': 'heslo:areal',
+    'areal': (BASE_URL_AMCR, 'heslo:areal'),
-    'kraj': 'ruian_kraj',
+    'kraj': (BASE_URL_AMCR, 'ruian_kraj'),
-    'organizace': 'organizace',
+    'organizace': (BASE_URL_AMCR, 'organizace'),
-    'okres': 'ruian_okres',
+    'okres': (BASE_URL_AMCR, 'ruian_okres'),
-    'katastr': 'ruian_katastr',
+    'katastr': (BASE_URL_AMCR, 'ruian_katastr'),
-    'vedouci': 'osoba',
+    'pian_presnost': (BASE_URL_AMCR, 'heslo:pian_presnost'),
-    'pian_presnost': 'heslo:pian_presnost',
+    'typ_lokality': (BASE_URL_AMCR, 'heslo:lokalita_typ'),
-    'typ_lokality': 'heslo:lokalita_typ',
+    'druh_lokality': (BASE_URL_AMCR, 'heslo:lokalita_druh'),
-    'druh_lokality': 'heslo:lokalita_druh',
+    'jistota': (BASE_URL_AMCR, 'heslo:jistota_urceni'),
-    'jistota': 'heslo:jistota_urceni',
+    'lokalita_zachovalost': (BASE_URL_AMCR, 'heslo:stav_dochovani'),
-    'lokalita_zachovalost': 'heslo:stav_dochovani',
+    'pristupnost': (BASE_URL_AMCR, 'heslo:pristupnost'),
-    'pristupnost': 'heslo:pristupnost'
+    'nalez_kategorie': (BASE_URL_AMCR, 'heslo:predmet_druh_kat'),
+    'druh_nalezu': (BASE_URL_AMCR, 'heslo:predmet_druh'),
+    'specifikace': (BASE_URL_AMCR, 'heslo:predmet_specifikace'),
+    'nalezove_okolnosti': (BASE_URL_AMCR, 'heslo:nalezove_okolnosti'),
+    'vedouci': (BASE_URL_DA, 'f_vedouci'),
+    'nalezce': (BASE_URL_DA, 'f_nalezce'),
 }
 
 NS = {
@@ -97,13 +103,19 @@ def load_all_data():
     return categorized_data
 
 
-def fetch_set(internal_name, api_set, task=None):
+def fetch_set(base_url, internal_name, api_set, task=None):
     dataset = []
-    params = {
+    params_amcr = {
         "verb": "ListRecords",
         "metadataPrefix": "oai_dc",
         "set": api_set
     }
+    params_da = {
+        "entity": "samostatny_nalez" if internal_name == "nalezce" else "akce",
+        "rows": 0,
+        "noFacets": "false",
+        "onlyFacets": "true"
+    }
 
     while True:
         # Check for cancellation at each iteration
@@ -111,75 +123,95 @@ def fetch_set(internal_name, api_set, task=None):
             return None
 
         try:
-            response = requests.get(BASE_URL, params=params, timeout=30)
+            if "digiarchiv" not in base_url:
-            response.raise_for_status()
+                response = requests.get(base_url, params=params_amcr, timeout=30)
-            root = ET.fromstring(response.content)  # nosec
+                response.raise_for_status()
+                root = ET.fromstring(response.content)  # nosec
 
-            records = root.findall('.//oai:record', NS)
+                records = root.findall('.//oai:record', NS)
-            for rec in records:
+                for rec in records:
-                metadata = rec.find('.//oai_dc:dc', NS)
+                    metadata = rec.find('.//oai_dc:dc', NS)
-                if metadata is not None:
+                    if metadata is not None:
-                    # Code (identifier)
+                        # Code (identifier)
-                    identifier_el = metadata.find('dc:identifier', NS)
+                        identifier_el = metadata.find('dc:identifier', NS)
-                    kod = (
+                        kod = (
-                        identifier_el.text
+                            identifier_el.text
-                        if identifier_el is not None
+                            if identifier_el is not None
-                        else ""
+                            else ""
-                    )
-
-                    # Title – filter out system labels "AMČR - ..."
-                    titles = metadata.findall('dc:title', NS)
-                    nazev = ""
-                    for t in titles:
-                        if (
-                            t.text
-                            and not t.text.startswith("AMČR -")
-                            and not t.text.startswith(" AMČR -")
-                        ):
-                            nazev = t.text
-                            break
-                    # If no title passed the filter, fall back
-                    # to the first available one
-                    if not nazev and titles:
-                        nazev = titles[0].text
-
-                    specialni_pripady = ['okres', 'katastr']
-
-                    if internal_name in specialni_pripady:
-                        kod = nazev
-
-                    if internal_name == 'pristupnost':
-                        kod = next(
-                            (
-                                t.text for t in titles
-                                if t.text
-                                and len(t.text) == 1
-                                and t.text.isalpha()
-                            ),
-                            None
                         )
-                        # Skip records without a valid one-letter code –
+
-                        # a None code would end up in the CSV and later
+                        # Title – filter out system labels "AMČR - ..."
-                        # in the API filter as the string "None"
+                        titles = metadata.findall('dc:title', NS)
-                        if not kod:
+                        nazev = ""
-                            continue
+                        for t in titles:
+                            if (
+                                t.text
+                                and not t.text.startswith("AMČR -")
+                                and not t.text.startswith(" AMČR -")
+                            ):
+                                nazev = t.text
+                                break
+                        # If no title passed the filter, fall back
+                        # to the first available one
+                        if not nazev and titles:
+                            nazev = titles[0].text
+
+                        specialni_pripady = ['okres', 'katastr']
+
+                        if internal_name in specialni_pripady:
+                            kod = nazev
+
+                        if internal_name == 'pristupnost':
+                            kod = next(
+                                (
+                                    t.text for t in titles
+                                    if t.text
+                                    and len(t.text) == 1
+                                    and t.text.isalpha()
+                                ),
+                                None
+                            )
+                            # Skip records without a valid one-letter code –
+                            # a None code would end up in the CSV and later
+                            # in the API filter as the string "None"
+                            if not kod:
+                                continue
+
+                        dataset.append({
+                            'Název': nazev,
+                            'Kód': kod,
+                            'Kategorie': internal_name
+                        })
+
+                # Pagination
+                token = root.find('.//oai:resumptionToken', NS)
+                if token is not None and token.text:
+                    params_amcr = {
+                        "verb": "ListRecords",
+                        "resumptionToken": token.text
+                    }
+                    time.sleep(0.5)
+                else:
+                    break
+            
+            else:
+                response = requests.get(base_url, params=params_da, timeout=30)
+                response.raise_for_status()
+                data_json = response.json()
+
+                records = data_json['facet_counts']['facet_fields'][api_set]
+
+                for r in records:
+
+                    nazev = r["name"]
 
                     dataset.append({
-                        'Název': nazev,
+                            'Název': nazev,
-                        'Kód': kod,
+                            'Kód': nazev,
-                        'Kategorie': internal_name
+                            'Kategorie': internal_name
-                    })
+                        })
-
+                
-            # Pagination
+                break                    
-            token = root.find('.//oai:resumptionToken', NS)
-            if token is not None and token.text:
-                params = {
-                    "verb": "ListRecords",
-                    "resumptionToken": token.text
-                }
-                time.sleep(0.5)
-            else:
-                break
 
         except Exception as e:
             QgsMessageLog.logMessage(
@@ -195,8 +227,13 @@ def download_heslare(task=None):
     ensure_codelists_dir()
     all_data = []
     total_sets = len(slovnicek)
+# index, (interni, api_nazev)
+    for index, (key, value) in enumerate(slovnicek.items()):
+
+        base_url = value[0]
+        interni = key
+        api_nazev = value[1]
 
-    for index, (interni, api_nazev) in enumerate(slovnicek.items()):
         # Check if the user cancelled the task via the QGIS taskbar
         if task and task.isCanceled():
             return False
@@ -206,7 +243,7 @@ def download_heslare(task=None):
             "AMČR", Qgis.Info)
 
         # Pass the task correctly to the updated fetch function
-        data = fetch_set(interni, api_nazev, task=task)
+        data = fetch_set(base_url, interni, api_nazev, task=task)
 
         if data is None:
             return False  # Cancelled mid-download
@@ -260,6 +297,16 @@ def refresh_globals():
     LOKALITA_ZACHOVALOST.update(data.get('lokalita_zachovalost', {}))
     PRISTUPNOST.clear()
     PRISTUPNOST.update(data.get('pristupnost', {}))
+    NALEZ_KATEGORIE.clear()
+    NALEZ_KATEGORIE.update(data.get('nalez_kategorie', {}))
+    DRUH_NALEZU.clear()
+    DRUH_NALEZU.update(data.get('druh_nalezu', {}))
+    SPECIFIKACE.clear()
+    SPECIFIKACE.update(data.get('specifikace', {}))
+    NALEZOVE_OKOLNOSTI.clear()
+    NALEZOVE_OKOLNOSTI.update(data.get('nalezove_okolnosti', {}))
+    NALEZCE.clear()
+    NALEZCE.update(data.get('nalezce', {}))
 
 
 # Initialize empty dicts that will be populated immediately below
@@ -277,5 +324,10 @@ DRUH_LOKALITY = {}
 JISTOTA = {}
 LOKALITA_ZACHOVALOST = {}
 PRISTUPNOST = {}
+NALEZ_KATEGORIE = {}
+DRUH_NALEZU = {}
+SPECIFIKACE = {}
+NALEZOVE_OKOLNOSTI = {}
+NALEZCE = {}
 
 refresh_globals()

amcr_viewer/amcr_dialog.py

@@ -11,7 +11,9 @@ from qgis.utils import iface
 from .amcr_codelists import (OBDOBI, TYP_AKCE, KRAJE, AREAL, ORGANIZACE,
                              OKRESY, KATASTRY, VEDOUCI, PIAN_PRESNOST,
                              TYP_LOKALITY, DRUH_LOKALITY, JISTOTA,
-                             LOKALITA_ZACHOVALOST, PRISTUPNOST,
+                             LOKALITA_ZACHOVALOST, PRISTUPNOST, 
+                             NALEZ_KATEGORIE, DRUH_NALEZU, SPECIFIKACE,
+                             NALEZOVE_OKOLNOSTI, NALEZCE,
                              download_heslare, refresh_globals)
 
 
@@ -44,16 +46,19 @@ class UpdateCodelistsTask(QgsTask):
             refresh_globals()
             QgsMessageLog.logMessage(
                 "Hesláře AMČR byly úspěšně aktualizovány.",
-                "AMČR", Qgis.Info)
+                "AMČR", Qgis.Info
+            )
         else:
             if self.isCanceled():
                 QgsMessageLog.logMessage(
                     "Aktualizace heslářů byla zrušena.",
-                    "AMČR", Qgis.Warning)
+                    "AMČR", Qgis.Warning
+                )
             else:
                 QgsMessageLog.logMessage(
                     f"Chyba aktualizace: {self.exception}",
-                    "AMČR", Qgis.Critical)
+                    "AMČR", Qgis.Critical
+                )
 
 
 class FilterableSelectionDialog(QDialog):
@@ -151,10 +156,25 @@ class AmcrFilterDialog(QDialog):
 
         # Cache dictionary to store selected codes for each category
         self.selection_cache = {
-            'organizace': [], 'kraj': [], 'obdobi': [], 'areal': [],
+            'organizace': [],
-            'typ_akce': [], 'okres': [], 'katastr': [], 'vedouci': [],
+            'kraj': [],
-            'pian_presnost': [], 'pristupnost': [], 'typ_lokality': [],
+            'obdobi': [],
-            'druh_lokality': [], 'jistota': [], 'lokalita_zachovalost': []
+            'areal': [],
+            'typ_akce': [],
+            'okres': [],
+            'katastr': [],
+            'vedouci': [],
+            'pian_presnost': [],
+            'pristupnost': [],
+            'typ_lokality': [],
+            'druh_lokality': [],
+            'jistota': [],
+            'lokalita_zachovalost': [],
+            'nalez_kategorie': [],
+            'druh_nalezu': [],
+            'specifikace': [],
+            'nalezove_okolnosti': [],
+            'nalezce': [],
         }
 
         layout = QVBoxLayout()
@@ -169,6 +189,8 @@ class AmcrFilterDialog(QDialog):
         if self.typ_dat == "akce":
             self.chk_posevidence = QCheckBox("Pouze pozitivní zjištění")
             layout.addWidget(self.chk_posevidence)
+            self.chk_proj_akce = QCheckBox("Pouze projektové akce")
+            layout.addWidget(self.chk_proj_akce)
 
         layout.addSpacing(10)
 
@@ -203,7 +225,7 @@ class AmcrFilterDialog(QDialog):
 
         # Filters valid for Akce
 
-        if self.typ_dat == "akce":
+        if self.typ_dat in ["samostatny_nalez", "akce"]:
             self.picker_org = self.setup_picker(
                 "Organizace",
                 'organizace',
@@ -211,6 +233,7 @@ class AmcrFilterDialog(QDialog):
             )
             layout.addWidget(self.picker_org)
 
+        if self.typ_dat == "akce":
             self.picker_vedouci = self.setup_picker(
                 "Vedoucí výzkumu",
                 'vedouci',
@@ -263,12 +286,49 @@ class AmcrFilterDialog(QDialog):
         self.picker_obdobi = self.setup_picker("Období", 'obdobi', OBDOBI)
         layout.addWidget(self.picker_obdobi)
 
-        self.picker_areal = self.setup_picker("Areál", 'areal', AREAL)
+        if self.typ_dat == "samostatny_nalez":
-        layout.addWidget(self.picker_areal)
+            self.picker_nalez_kategorie = self.setup_picker(
+                "Kategorie nálezu",
+                'nalez_kategorie',
+                NALEZ_KATEGORIE
+            )
+            layout.addWidget(self.picker_nalez_kategorie)
 
-        # Option to download related components table
+            self.picker_druh_nalezu = self.setup_picker(
-        self.chk_komponenty = QCheckBox("Načíst komponenty")
+                "Druh nálezu",
-        layout.addWidget(self.chk_komponenty)
+                'druh_nalezu',
+                DRUH_NALEZU
+            )
+            layout.addWidget(self.picker_druh_nalezu)
+
+            self.picker_specifikace = self.setup_picker(
+                "Specifikace nálezu",
+                'specifikace',
+                SPECIFIKACE
+            )
+            layout.addWidget(self.picker_specifikace)
+
+            self.picker_nalezove_okolnosti = self.setup_picker(
+                "Okolnosti nálezu",
+                'nalezove_okolnosti',
+                NALEZOVE_OKOLNOSTI
+            )
+            layout.addWidget(self.picker_nalezove_okolnosti)
+
+            self.picker_nalezce = self.setup_picker(
+                "Nálezce",
+                'nalezce',
+                NALEZCE
+            )
+            layout.addWidget(self.picker_nalezce)
+
+        if self.typ_dat != "samostatny_nalez":
+            self.picker_areal = self.setup_picker("Areál", 'areal', AREAL)
+            layout.addWidget(self.picker_areal)
+
+            # Option to download related components table
+            self.chk_komponenty = QCheckBox("Načíst komponenty")
+            layout.addWidget(self.chk_komponenty)
 
         # Warning label
         self.lbl_komponenty_warning = QLabel(
@@ -284,9 +344,10 @@ class AmcrFilterDialog(QDialog):
         self.lbl_komponenty_warning.setVisible(False)
         layout.addWidget(self.lbl_komponenty_warning)
 
-        self.chk_komponenty.toggled.connect(
+        if self.typ_dat != "samostatny_nalez":
-            self.lbl_komponenty_warning.setVisible
+            self.chk_komponenty.toggled.connect(
-        )
+                self.lbl_komponenty_warning.setVisible
+            )
 
         # Pushes everything above to the top
         layout.addStretch(1)
@@ -361,7 +422,7 @@ class AmcrFilterDialog(QDialog):
             self.selection_cache[cache_key] = [
                 'HES-000861',
                 'HES-000862',
-                'HES-000863'
+                'HES-000863',
             ]
 
         btn.clicked.connect(open_dialog)
@@ -453,22 +514,25 @@ class AmcrFilterDialog(QDialog):
         if self.typ_dat == "akce":
             if self.chk_posevidence.isChecked():
                 filters['posevidence'] = 'true'
-            if self.selection_cache['organizace']:
+            if self.chk_proj_akce.isChecked():
-                filters['f_organizace'] = self.selection_cache['organizace']
+                filters['proj_akce'] = 'true'
-            if self.selection_cache['typ_akce']:
-                filters['f_typ_vyzkumu'] = self.selection_cache['typ_akce']
-            if self.selection_cache['vedouci']:
-                filters['f_vedouci'] = self.selection_cache['vedouci']
 
-        if self.typ_dat == "lokalita":
+        if self.selection_cache['typ_akce']:
-            if self.selection_cache['typ_lokality']:
+            filters['f_typ_vyzkumu'] = self.selection_cache['typ_akce']
-                filters['f_typ_lokality'] = self.selection_cache['typ_lokality']
+        if self.selection_cache['vedouci']:
-            if self.selection_cache['druh_lokality']:
+            filters['f_vedouci'] = self.selection_cache['vedouci']
-                filters['f_druh_lokality'] = self.selection_cache['druh_lokality']
+
-            if self.selection_cache['jistota']:
+        if self.selection_cache['organizace']:
-                filters['f_jistota'] = self.selection_cache['jistota']
+            filters['f_organizace'] = self.selection_cache['organizace']                
-            if self.selection_cache['lokalita_zachovalost']:
+
-                filters['f_lokalita_zachovalost'] = self.selection_cache['lokalita_zachovalost']
+        if self.selection_cache['typ_lokality']:
+            filters['f_typ_lokality'] = self.selection_cache['typ_lokality']
+        if self.selection_cache['druh_lokality']:
+            filters['f_druh_lokality'] = self.selection_cache['druh_lokality']
+        if self.selection_cache['jistota']:
+            filters['f_jistota'] = self.selection_cache['jistota']
+        if self.selection_cache['lokalita_zachovalost']:
+            filters['f_lokalita_zachovalost'] = self.selection_cache['lokalita_zachovalost']
 
         return filters
 

amcr_viewer/amcr_tools.py

@@ -26,6 +26,17 @@ LAST_LOGIN_ERROR: str | None = None
 # a second download while the first one is still running
 _LOADING = False
 
+archeologicky_zaznam_l = [
+    "akce",
+    "lokalita",
+]
+
+typ_dat_vocab = {
+    "akce": "Akce",
+    "lokalita": "Lokalita",
+    "samostatny_nalez": "PAS",
+}
+
 
 def _log(msg: str, level=Qgis.MessageLevel.Info):
     """
@@ -283,7 +294,7 @@ def load_amcr_data(canvas, bb, filters=None,
         base_params = {
             "mapa": "true",
             "sort": "ident_cely asc",
-            "entity": typ_dat
+            "entity": typ_dat,
         }
 
         # Restrict search to map window if requested
@@ -317,6 +328,12 @@ def load_amcr_data(canvas, bb, filters=None,
             else False
         )
 
+        only_projektove_akce = (
+            filters.get('proj_akce') == 'true'
+            if filters
+            else False
+        )
+
         # Check whether we should filter results based on component filters
         filter_areal = "f_areal" in filters if filters else False
         filter_datace = "f_obdobi" in filters if filters else False
@@ -434,266 +451,289 @@ def load_amcr_data(canvas, bb, filters=None,
             return ", ".join([str(x) for x in val if x])
 
         # Process each downloaded metadata record
-        for doc in docs:
+        if typ_dat in archeologicky_zaznam_l:
-            piani = doc.get('az_dj_pian', [])
+            for doc in docs:
-            if not piani:
+                piani = doc.get('az_dj_pian', [])
-                continue
+                if not piani:
-
-            actions_with_geom += 1
-
-            # Extract protected fields ('or {}' – key may hold None)
-            az_chranene = doc.get('az_chranene_udaje') or {}
-            chranene = (
-                doc.get('akce_chranene_udaje')
-                or doc.get('lokalita_chranene_udaje')
-                or {}
-            )
-
-            # Format additional cadastral areas from nested dicts
-            dalsi_kat = az_chranene.get('dalsi_katastr', [])
-            dalsi_kat_str = ""
-            if isinstance(dalsi_kat, list):
-                items = [
-                    x.get('value', '') if isinstance(x, dict) else str(x)
-                    for x in dalsi_kat
-                ]
-                dalsi_kat_str = ", ".join([i for i in items if i])
-
-            lokalizace = chranene.get('lokalizace_okolnosti', "")
-            lokalita_nazev = chranene.get('nazev', "")
-            lokalita_popis = chranene.get('popis', "")
-
-            # Core metadata structure
-            meta = {
-                "ident_cely": doc.get('ident_cely', ''),
-                "az_okres": g(doc, 'az_okres'),
-                "katastr": g_list(doc, 'katastr'),
-                "dalsi_katastr": dalsi_kat_str,
-                "pristupnost": g(doc, 'pristupnost'),
-                "loc": g_list(doc, 'loc')
-            }
-
-            # Add entity-specific metadata
-            if typ_dat == "akce":
-                meta.update({
-                    "akce_hlavni_vedouci": g(
-                        doc,
-                        'akce_hlavni_vedouci'
-                    ),
-                    "akce_organizace": tr_code(g(
-                        doc,
-                        'akce_organizace'
-                    )),
-                    "akce_specifikace_data": tr_code(g(
-                        doc,
-                        'akce_specifikace_data'
-                    )),
-                    "akce_datum_zahajeni": g(
-                        doc,
-                        'akce_datum_zahajeni'
-                    ),
-                    "akce_datum_ukonceni": g(
-                        doc,
-                        'akce_datum_ukonceni'
-                    ),
-                    "akce_hlavni_typ": tr_code(g(
-                        doc,
-                        'akce_hlavni_typ'
-                    )),
-                    "akce_vedlejsi_typ": g_list(
-                        doc,
-                        'akce_vedlejsi_typ',
-                        translate=True
-                    ),
-                    "lokalizace_okolnosti": (
-                        str(lokalizace)
-                        if lokalizace
-                        else ""
-                    ),
-                    "akce_je_nz": (
-                        "Ano"
-                        if doc.get('akce_je_nz') is True
-                        else "Ne"
-                    ),
-                })
-
-            elif typ_dat == "lokalita":
-                meta.update({
-                    "lokalita_nazev": lokalita_nazev,
-                    "lokalita_popis": lokalita_popis,
-                    "lokalita_zachovalost": tr_code(g(
-                        doc,
-                        'lokalita_zachovalost'
-                    )),
-                    "lokalita_druh": tr_code(g(
-                        doc,
-                        'lokalita_druh'
-                    )),
-                    "lokalita_typ": tr_code(g(
-                        doc,
-                        'lokalita_typ_lokality'
-                    )),
-                })
-
-            # Documentation units (DJ) within the record
-            djs = doc.get('az_dokumentacni_jednotka', [])
-
-            for dj in djs:
-                # Skip negative evidence units if requested
-                if skip_negativni and dj.get('dj_negativni_jednotka') is True:
                     continue
 
-                komps = dj.get('dj_komponenta', [])
+                if only_projektove_akce and not doc.get("akce_projekt", False):
+                    continue
 
-                if filter_areal or filter_datace:
+                actions_with_geom += 1
-                    if not komps:
-                        continue
-                    if not any(
-                        komp_projde_filtrem(
-                            komp, filter_areal,
-                            filter_datace, filters
-                        )
-                        for komp in komps
-                    ):
-                        continue
 
-                dj_id = dj.get('ident_cely')
+                # Extract protected fields ('or {}' – key may hold None)
-                dj_typ = dj.get('dj_typ')
+                az_chranene = doc.get('az_chranene_udaje') or {}
+                chranene = (
+                    doc.get('akce_chranene_udaje')
+                    or doc.get('lokalita_chranene_udaje')
+                    or {}
+                )
 
-                # Merge shared metadata with documentation unit-specific fields
+                # Format additional cadastral areas from nested dicts
-                dj_meta = {
+                dalsi_kat = az_chranene.get('dalsi_katastr', [])
-                    **meta,
+                dalsi_kat_str = ""
-                    'dj_id': dj_id,
+                if isinstance(dalsi_kat, list):
-                    'dj_typ_value': dj_typ.get('value') if dj_typ else "",
+                    items = [
-                    'dj_negativni': (
+                        x.get('value', '') if isinstance(x, dict) else str(x)
-                        "Negativní"
+                        for x in dalsi_kat
-                        if dj.get('dj_negativni_jednotka') is True
+                    ]
-                        else "Pozitivní"
+                    dalsi_kat_str = ", ".join([i for i in items if i])
-                    )
+
+                lokalizace = chranene.get('lokalizace_okolnosti', "")
+                lokalita_nazev = chranene.get('nazev', "")
+                lokalita_popis = chranene.get('popis', "")
+
+                # Core metadata structure
+                meta = {
+                    "ident_cely": doc.get('ident_cely', ''),
+                    "az_okres": g(doc, 'az_okres'),
+                    "katastr": g_list(doc, 'katastr'),
+                    "dalsi_katastr": dalsi_kat_str,
+                    "pristupnost": g(doc, 'pristupnost'),
+                    "loc": g_list(doc, 'loc'),
                 }
 
-                # Link Documentation Unit to Geometry (PIAN)
+                # Add entity-specific metadata
-                dj_pian = dj.get('dj_pian')
+                if typ_dat == "akce":
-                if dj_pian:
+                    meta.update({
-                    dj_pian_value = dj_pian.get('id')
+                        "akce_hlavni_vedouci": g(
-                    if dj_pian_value:
+                            doc,
-                        target_pian_ids.add(dj_pian_value)
+                            'akce_hlavni_vedouci'
-                        if dj_pian_value not in pian_lookup:
+                        ),
-                            pian_lookup[dj_pian_value] = []
+                        "akce_organizace": tr_code(g(
+                            doc,
+                            'akce_organizace'
+                        )),
+                        "akce_specifikace_data": tr_code(g(
+                            doc,
+                            'akce_specifikace_data'
+                        )),
+                        "akce_datum_zahajeni": g(
+                            doc,
+                            'akce_datum_zahajeni'
+                        ),
+                        "akce_datum_ukonceni": g(
+                            doc,
+                            'akce_datum_ukonceni'
+                        ),
+                        "akce_hlavni_typ": tr_code(g(
+                            doc,
+                            'akce_hlavni_typ'
+                        )),
+                        "akce_vedlejsi_typ": g_list(
+                            doc,
+                            'akce_vedlejsi_typ',
+                            translate=True
+                        ),
+                        "lokalizace_okolnosti": (
+                            str(lokalizace)
+                            if lokalizace
+                            else ""
+                        ),
+                        "akce_je_nz": (
+                            "Ano"
+                            if doc.get('akce_je_nz') is True
+                            else "Ne"
+                        ),
+                        "projekt": g(
+                            doc,
+                            'akce_projekt',
+                            ""
+                        ),
+                    })
 
-                        if komponenty == "true":
+                elif typ_dat == "lokalita":
-                            # One feature per component –
+                    meta.update({
-                            # all data on a single row, no relations needed
+                        "lokalita_nazev": lokalita_nazev,
-                            if komps:
+                        "lokalita_popis": lokalita_popis,
-                                for komp in komps:
+                        "lokalita_zachovalost": tr_code(g(
-                                    if not komp_projde_filtrem(
+                            doc,
-                                        komp, filter_areal,
+                            'lokalita_zachovalost'
-                                        filter_datace, filters
+                        )),
-                                    ):
+                        "lokalita_druh": tr_code(g(
+                            doc,
+                            'lokalita_druh'
+                        )),
+                        "lokalita_typ": tr_code(g(
+                            doc,
+                            'lokalita_typ_lokality'
+                        )),
+                    })
+
+                # Documentation units (DJ) within the record
+                djs = doc.get('az_dokumentacni_jednotka', [])
+
+                for dj in djs:
+                    # Skip negative evidence units if requested
+                    if skip_negativni and dj.get('dj_negativni_jednotka') is True:
+                        continue
+
+                    komps = dj.get('dj_komponenta', [])
+
+                    if filter_areal or filter_datace:
+                        if not komps:
+                            continue
+                        if not any(
+                            komp_projde_filtrem(
+                                komp, filter_areal,
+                                filter_datace, filters
+                            )
+                            for komp in komps
+                        ):
+                            continue
+
+                    dj_id = dj.get('ident_cely')
+                    dj_typ = dj.get('dj_typ')
+
+                    # Merge shared metadata with documentation unit-specific fields
+                    dj_meta = {
+                        **meta,
+                        'dj_id': dj_id,
+                        'dj_typ_value': dj_typ.get('value') if dj_typ else "",
+                        'dj_negativni': (
+                            "Negativní"
+                            if dj.get('dj_negativni_jednotka') is True
+                            else "Pozitivní"
+                        )
+                    }
+
+                    # Link Documentation Unit to Geometry (PIAN)
+                    dj_pian = dj.get('dj_pian')
+                    if dj_pian:
+                        dj_pian_value = dj_pian.get('id')
+                        if dj_pian_value:
+                            target_pian_ids.add(dj_pian_value)
+                            if dj_pian_value not in pian_lookup:
+                                pian_lookup[dj_pian_value] = []
+
+                            if komponenty == "true":
+                                # One feature per component –
+                                # all data on a single row, no relations needed
+                                if komps:
+                                    for komp in komps:
+                                        if not komp_projde_filtrem(
+                                            komp, filter_areal,
+                                            filter_datace, filters
+                                        ):
+                                            continue
+
+                                        komp_meta = {
+                                            **dj_meta,
+                                            'komponenta_id': komp.get(
+                                                'ident_cely',
+                                                ""
+                                                ),
+                                            'komponenta_areal': (
+                                                komp.get('komponenta_areal')
+                                                or {}
+                                            ).get('value', ""),
+                                            'komponenta_obdobi': (
+                                                komp.get('komponenta_obdobi')
+                                                or {}
+                                            ).get('value', ""),
+                                        }
+                                        pian_lookup[dj_pian_value].append(komp_meta)
+                                        target_pian_ids_count += 1
+                                else:
+                                    # DJ without components — still include
+                                    # with empty component fields
+                                    if filter_areal or filter_datace:
                                         continue
 
-                                    komp_meta = {
+                                    empty_meta = {
                                         **dj_meta,
-                                        'komponenta_id': komp.get(
+                                        'komponenta_id': "",
-                                            'ident_cely',
+                                        'komponenta_areal': "",
-                                            ""
+                                        'komponenta_obdobi': "",
-                                            ),
-                                        'komponenta_areal': (
-                                            komp.get('komponenta_areal')
-                                            or {}
-                                        ).get('value', ""),
-                                        'komponenta_obdobi': (
-                                            komp.get('komponenta_obdobi')
-                                            or {}
-                                        ).get('value', ""),
                                     }
-                                    pian_lookup[dj_pian_value].append(komp_meta)
+                                    pian_lookup[dj_pian_value].append(empty_meta)
                                     target_pian_ids_count += 1
                             else:
-                                # DJ without components — still include
-                                # with empty component fields
-                                if filter_areal or filter_datace:
-                                    continue
-
-                                empty_meta = {
-                                    **dj_meta,
-                                    'komponenta_id': "",
-                                    'komponenta_areal': "",
-                                    'komponenta_obdobi': "",
-                                }
-                                pian_lookup[dj_pian_value].append(empty_meta)
                                 target_pian_ids_count += 1
-                        else:
+                                pian_lookup[dj_pian_value].append(dj_meta)
-                            target_pian_ids_count += 1
+
-                            pian_lookup[dj_pian_value].append(dj_meta)
+            if not target_pian_ids:
+                iface.messageBar().pushMessage(
+                    "AMCR",
+                    f"Nalezeno {len(docs)} záznamů, ale žádný nemá geometrii.",
+                    level=Qgis.MessageLevel.Warning
+                )
+                return
+
+            # ==========================================
+            # C) GEOMETRY FETCHING (PIAN)
+            # ==========================================
+            ids_list = list(target_pian_ids)
+            total_pians = len(ids_list)
+            docs_pian = []
+            # Geometry requests are batch-processed
+            # to stay under URL length limits:
+            BATCH_PIAN = 200
 
-        if not target_pian_ids:
             iface.messageBar().pushMessage(
                 "AMCR",
-                f"Nalezeno {len(docs)} záznamů, ale žádný nemá geometrii.",
+                f"Záznamů: {len(docs)} (z toho {actions_with_geom} s mapou). "
-                level=Qgis.MessageLevel.Warning
+                f"Stahuji {total_pians} unikátních geometrií, "
+                f"vykresluji {target_pian_ids_count} geometrií...",
+                level=Qgis.MessageLevel.Info
             )
-            return
 
-        # ==========================================
+            fl_pian = [
-        # C) GEOMETRY FETCHING (PIAN)
+                "ident_cely",
-        # ==========================================
+                "pian_typ",
-        ids_list = list(target_pian_ids)
+                "pian_chranene_udaje",
-        total_pians = len(ids_list)
+                "pian_presnost",
-        docs_pian = []
+            ]
-        # Geometry requests are batch-processed
-        # to stay under URL length limits:
-        BATCH_PIAN = 200
 
-        iface.messageBar().pushMessage(
+            for i in range(0, total_pians, BATCH_PIAN):
-            "AMCR",
+                batch = ids_list[i: i + BATCH_PIAN]
-            f"Záznamů: {len(docs)} (z toho {actions_with_geom} s mapou). "
+                or_query = " OR ".join(batch)
-            f"Stahuji {total_pians} unikátních geometrií, "
+                fq_pian = f"ident_cely:({or_query})"
-            f"vykresluji {target_pian_ids_count} geometrií...",
-            level=Qgis.MessageLevel.Info
-        )
 
-        fl_pian = [
+                params_pian = {
-            "ident_cely", "pian_typ",
+                    "mapa": "true",
-            "pian_chranene_udaje", "pian_presnost"
+                    "entity": "pian",
-        ]
+                    "q": fq_pian,
+                    "rows": len(batch),
+                    "fl": ",".join(fl_pian),
+                }
+                try:
+                    QApplication.processEvents()
+                    r_json = _api_get_json(url, params=params_pian, timeout=15)
+                    docs_pian.extend(r_json.get('response', {}).get('docs', []))
+                except requests.exceptions.RequestException as e:
+                    # Network is down – stop immediately instead of
+                    # uselessly retrying every remaining batch
+                    network_error = True
+                    QgsMessageLog.logMessage(
+                        f"Chyba sítě při stahování geometrií PIAN: {e}",
+                        "AMČR", Qgis.MessageLevel.Critical
+                    )
+                    break
+                except Exception as e:
+                    QgsMessageLog.logMessage(
+                        f"Chyba PIAN: {e}",
+                        "AMČR", Qgis.MessageLevel.Warning
+                    )
 
-        for i in range(0, total_pians, BATCH_PIAN):
+        elif typ_dat == "samostatny_nalez":
-            batch = ids_list[i: i + BATCH_PIAN]
+            for doc in docs:
-            or_query = " OR ".join(batch)
+                loc = g(doc, "loc", [])
-            fq_pian = f"ident_cely:({or_query})"
+                if not loc:
+                    continue
 
-            params_pian = {
+                actions_with_geom += 1
-                "mapa": "true",
+
-                "entity": "pian",
+                sn_chranene = doc.get("samostatny_nalez_chranene_udaje") or {}
-                "q": fq_pian,
+
-                "rows": len(batch),
+                
-                "fl": ",".join(fl_pian)
-            }
-            try:
-                QApplication.processEvents()
-                r_json = _api_get_json(url, params=params_pian, timeout=15)
-                docs_pian.extend(r_json.get('response', {}).get('docs', []))
-            except requests.exceptions.RequestException as e:
-                # Network is down – stop immediately instead of
-                # uselessly retrying every remaining batch
-                network_error = True
-                QgsMessageLog.logMessage(
-                    f"Chyba sítě při stahování geometrií PIAN: {e}",
-                    "AMČR", Qgis.MessageLevel.Critical
-                )
-                break
-            except Exception as e:
-                QgsMessageLog.logMessage(
-                    f"Chyba PIAN: {e}",
-                    "AMČR", Qgis.MessageLevel.Warning
-                )
 
         # ==========================================
         # D) LAYER CREATION (QGIS Memory Layers)
         # ==========================================
 
-        archeologicky_zaznam = "Akce" if typ_dat == "akce" else "Lokalita"
+        archeologicky_zaznam = typ_dat_vocab[typ_dat]
 
         # Initialize three layers for different geometry types (S-JTSK CRS)
         vl_poly = QgsVectorLayer(
@@ -725,7 +765,7 @@ def load_amcr_data(canvas, bb, filters=None,
             QgsField("odkaz_do_digiarchivu", QMetaType.Type.QString),
             QgsField("okres", QMetaType.Type.QString),
             QgsField("katastr", QMetaType.Type.QString),
-            QgsField("dalsi_katastry", QMetaType.Type.QString)
+            QgsField("dalsi_katastry", QMetaType.Type.QString),
         ]
 
         # Extend table based on data type
@@ -741,6 +781,7 @@ def load_amcr_data(canvas, bb, filters=None,
                 QgsField("vedlejsi_typ", QMetaType.Type.QString),
                 QgsField("zjisteni", QMetaType.Type.QString),
                 QgsField("nahrazuje_NZ", QMetaType.Type.QString),
+                QgsField("projekt", QMetaType.Type.QString),
             ]
         elif typ_dat == "lokalita":
             cols += [
@@ -748,7 +789,7 @@ def load_amcr_data(canvas, bb, filters=None,
                 QgsField("popis_lokality", QMetaType.Type.QString),
                 QgsField("typ_lokality", QMetaType.Type.QString),
                 QgsField("druh_lokality", QMetaType.Type.QString),
-                QgsField("zachovalost", QMetaType.Type.QString)
+                QgsField("zachovalost", QMetaType.Type.QString),
             ]
 
         cols.append(QgsField("Přístupnost", QMetaType.Type.QString))
@@ -784,6 +825,7 @@ def load_amcr_data(canvas, bb, filters=None,
             "komponenta": "Komponenta",
             "komponenta_areal": "Areál",
             "komponenta_obdobi": "Období",
+            "projekt": "Projekt",
         }
 
         if komponenty == "true":
@@ -904,7 +946,7 @@ def load_amcr_data(canvas, bb, filters=None,
                                 + meta['ident_cely'],
                                 meta['az_okres'],
                                 meta['katastr'],
-                                meta['dalsi_katastr']
+                                meta['dalsi_katastr'],
                             ]
                             if is_akce:
                                 atributy.extend([
@@ -917,7 +959,8 @@ def load_amcr_data(canvas, bb, filters=None,
                                     meta['akce_hlavni_typ'],
                                     meta['akce_vedlejsi_typ'],
                                     meta['dj_negativni'],
-                                    meta['akce_je_nz']
+                                    meta['akce_je_nz'],
+                                    meta['projekt'],
                                 ])
                             else:
                                 atributy.extend([
@@ -925,7 +968,7 @@ def load_amcr_data(canvas, bb, filters=None,
                                     meta['lokalita_popis'],
                                     meta['lokalita_typ'],
                                     meta['lokalita_druh'],
-                                    meta['lokalita_zachovalost']
+                                    meta['lokalita_zachovalost'],
                                 ])
 
                             atributy.append(meta['pristupnost'])
@@ -955,12 +998,12 @@ def load_amcr_data(canvas, bb, filters=None,
             (feats_pt, vl_point, "Body"),
         ]
 
-        for f, l, n in layers_to_process:
+        for f, L, n in layers_to_process:
             if f:
-                l.dataProvider().addFeatures(f)
+                L.dataProvider().addFeatures(f)
-                l.updateExtents()
+                L.updateExtents()
-                l.setName(f"AMCR_{archeologicky_zaznam}_{n}")
+                L.setName(f"AMCR_{archeologicky_zaznam}_{n}")
-                proj.addMapLayer(l)
+                proj.addMapLayer(L)
                 added += len(f)
 
         if network_error:

amcr_viewer/amcr_viewer.py

@@ -90,6 +90,7 @@ class AmcrViewer:
         """
         # Define paths for action-specific icons
         icon_akce_path = os.path.join(self.plugin_dir, 'akce.png')
+        icon_pas_path = os.path.join(self.plugin_dir, 'akce.png')
         icon_lokality_path = os.path.join(self.plugin_dir, 'lokality.png')
         icon_amcr_help_path = os.path.join(self.plugin_dir, 'amcr-help.png')
 
@@ -109,6 +110,16 @@ class AmcrViewer:
         )
         self.plugin_menu.addAction(self.action_download_akce)
 
+        self.action_download_pas = self.add_action(
+            icon_path=icon_pas_path,
+            text=self.tr(u'Stáhnout data samostatných nálezů | AMČR Viewer'),
+            callback=lambda checked=False: self.run_download('samostatny_nalez'),
+            parent=self.iface.mainWindow(),
+            add_to_menu=False,
+            add_to_toolbar=False
+        )
+        self.plugin_menu.addAction(self.action_download_pas)
+
         self.action_download_lokality = self.add_action(
             icon_path=icon_lokality_path,
             text=self.tr(u'Stáhnout data lokalit | AMČR Viewer'),