soneta-place-def-elementow

.gitignore

@@ -1 +1,2 @@
-**-workspace/**
+**-workspace/**
+**/.DS_Store

soneta-place-def-elementow/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: soneta-place-def-elementow
+description: Tworzenie, konfiguracja i modyfikacja definicji elementów wynagrodzenia w enova365/Soneta przez MCP soneta_ui. Obejmuje algorytmy naliczania (kreator, edytor C#, wbudowane), wzorce algorytmiczne, receptury kodu C# dla elementów płacowych, konfigurację PIT/ZUS/nieobecności. Używaj tego skilla ZAWSZE gdy użytkownik (1) chce utworzyć nową definicję elementu wynagrodzenia w enova365; (2) pyta o algorytm naliczania elementu płacowego (kreator, edytor, kod C#); (3) chce skonfigurować element wynagrodzenia — zakładki Ogólne, Deklaracje, Nieobecności, Algorytm; (4) potrzebuje kodu C# do edytora algorytmu (_Param, _Wylicz, _Wartość1h); (5) pyta o wzorce algorytmiczne dla dodatków, nieobecności, zasiłków; (6) wspomina 'definicja elementu', 'element wynagrodzenia', 'algorytm płacowy', 'kreator algorytmu', 'edytor algorytmu', 'WypSkladnik', 'WypElement', 'premia procentowa', 'dodatek stażowy', 'zasiłek chorobowy', 'ekwiwalent za urlop'; (7) chce napisać recepturę kodu płacowego (iterowanie po elementach, staż pracy, wymiar etatu, czas pracy, wskaźniki, cechy pracownika).
+---
+
+# Definicje elementów wynagrodzenia — enova365
+
+Ten skill zawiera kompletną wiedzę o tworzeniu i konfigurowaniu definicji elementów wynagrodzenia w enova365. Wiedza jest podzielona na pliki referencyjne — czytaj odpowiedni plik w zależności od potrzeby.
+
+## Spis treści referencji
+
+| Plik | Kiedy czytać | Zawartość |
+|---|---|---|
+| `references/algorytmy-naliczania.md` | Gdy trzeba wybrać typ algorytmu, skonfigurować kreator lub napisać kod edytora | Typy algorytmów, parametry kreatora (podstawa, mnożnik, korekty), struktura kodu C# edytora, przykłady kompletnych algorytmów |
+| `references/wzorce-algorytmiczne.md` | Gdy trzeba znaleźć najbliższy wzorzec dla nowego elementu | 12 wzorców dla Dodatków (A-L), 5 dla Nieobecności (A-E), 5 dla Dodatków automatycznych (A-E) — z analizy ~247 definicji |
+| `references/receptury-kodu.md` | Gdy trzeba napisać konkretny fragment kodu C# | 24 kategorie gotowych fragmentów: iterowanie po elementach, wynagrodzenie zasadnicze, nieobecności, wymiar etatu, czas pracy, okresy, staż, cechy, wskaźniki, parametry dodatku, zaokrąglenia, netto→brutto, urlopy, debugowanie |
+| `references/api-algorytmow.md` | Gdy potrzebna jest referencja API — pola, metody, klasy, typy | Pola WypSkladnik, metody pomocnicze, klasy naliczania, moduły, dostęp do konfiguracji, operacje na typach danych, sygnatury metod |
+| `references/metody-sterujace-naliczaniem.md` | Gdy element musi wpływać na podstawy urlopów lub zasiłków | Metody _PodstawaUrlopu, _PodstawaZasiłku, klasa PodstawaZasiłkuArgs |
+
+## Lokalizacja w programie
+
+Folder konfiguracyjny: `Ustawienia/Kadry i płace/Płace/Elementy wynagrodzenia`
+
+Formularz zawiera:
+- **Listę definicji** (gridID: `_New_CfgDefElementowExtender_DefElementow`)
+- **Filtry** pod listą:
+  - `Rodzaj` — typ elementu (31 rodzajów)
+  - `Zakres` — Standardowe / Definiowane / **Razem** (pokaż wszystkie)
+  - `Stan` — Aktywne / Zablokowane / **Razem** (pokaż wszystkie)
+
+Aby zobaczyć wszystkie definicje, ustaw Zakres=Razem i Stan=Razem.
+
+## Rodzaje elementów wynagrodzenia
+
+| Rodzaj | Klasa elementu | Typowe zastosowanie |
+|---|---|---|
+| **Etat** | `WypElementEtat` | Wynagrodzenie zasadnicze (mies./godz.), dochód deklarowany |
+| **Dodatek** | `WypElementDodatek` | Premie, dodatki (funkcyjny, stażowy), ekwiwalenty, ryczałty, odprawy, potrącenia, korekty, odsetki |
+| **Dodatek automatyczny** | `WypElementDodatekAutomatyczny` | Elementy naliczane automatycznie (PPK, potrącenie OPP, wynagrodzenie postojowe) |
+| **Nieobecność** | `WypElementNieobecnosc` | Wynagrodzenie za urlopy, zasiłki (chorobowy, macierzyński, opiekuńczy), świadczenia rehabilitacyjne |
+| **Nadgodziny I/II/św** | `WypElementNadgodziny` | Dopłata do nadgodzin 50%, 100%, za święta |
+| **Nocne** | `WypElementNocne` | Dopłata za godziny nocne |
+| **Akord** | `WypElementAkord` | Wynagrodzenie akordowe |
+| **Nagroda** | `WypElementNagroda` | Nagroda pieniężna |
+| **Kara** | `WypElementKara` | Kara pieniężna |
+| **Umowa** | `WypElementUmowa` | Umowy cywilnoprawne, IFT-1, PIT-8A, PIT-R |
+| **Umowa rozliczenie** | `WypElementUmowa` | Wyrównania umów zlecenia, kontraktów menedżerskich |
+| **Świadczenie** | `WypElementSwiadczenie` | Świadczenia socjalne (z limitem i bez) |
+| **Odchyłki** | `WypElementOdchylki` | Rozliczenie odchyłek czasu pracy, przerwy na karmienie |
+| **Zaliczka / Zaliczka zwrot** | `WypElementZaliczka` | Zaliczki i ich spłaty |
+| **Pożyczka / Pożyczka spłata** | `WypElementPozyczka` | Pożyczki KZP/ZFM, spłaty, umorzenia |
+| **Fund poż składka/wpisowe/wycofanie** | — | Składki KZP/ZFM, wpisowe, wycofanie wkładu |
+| **Wyrównanie do minimalnej** | `WypElementWyrownanie` | Wyrównanie do minimalnej płacy |
+| **Zajęcie komornicze** | `WypElementZajecie` | Alimenty, zajęcia komornicze |
+| **Przychód od składki pracodawcy PPK** | — | Przychód PPK, zwroty składek PPK |
+| **Zwrot nadpłaty PPK** | — | Zwroty nadpłat PPK |
+| **Zbieg pracy i rodzicielstwa** | — | Urlop wychowawczy/macierzyński przy zbiegu z pracą |
+
+## Zakładki formularza definicji
+
+### Ogólne (`DefinicjaElementuProPage`)
+
+| Pole | Opis | Przykładowe wartości |
+|---|---|---|
+| **Nazwa** | Unikalna nazwa definicji | `Premia procentowa` |
+| **Nazwa wyświetlana** | Nazwa wyświetlana operatorowi | `Premia procentowa` |
+| **Skrót** | Krótki identyfikator | `Prm.procent` |
+| **Kod** | Opcjonalny kod zewnętrzny | — |
+| **Blokada** | Czy definicja zablokowana | Nie/Tak |
+| **Naliczanie** | Płatna z góry / z dołu | `PłatnaZDołu` |
+| **Typ okresu naliczania** | Jak często naliczać | Jednorazowa, Każdy okres, Co n miesięcy |
+| **Przyrównuj do najniższego** | Czy wliczać do wyrównania | Tak/Nie |
+| **Korygowany** | Czy generować korektę przy zmianie | Tak/Nie |
+| **Generuj zerowy element** | Czy generować przy wartości 0 | Tak/Nie |
+| **Definicja listy płac** | Do której listy płac | LPE (objectID=3) |
+| **Rodzaj wypłaty** | Etat/Umowa/InnaWyplata | `Etat` |
+| **Kolejność na listach płac** | Porządek sortowania | 0-99 |
+| **Identyfikator** | Identyfikator C# (auto) | `Premia_Procentowa` |
+
+### Deklaracje (`DefinicjaElementuDeklaracjePage`)
+
+Konfiguracja podatków i składek ZUS:
+
+| Sekcja | Kluczowe pola |
+|---|---|
+| **PIT** | Pozycja PIT, typ zaliczki (wg skali / procentowe), koszty uzyskania, ulga podatkowa |
+| **ZUS** | Podstawa składek społecznych, składka zdrowotna, FP, FGŚP, kod RSA |
+| **Priorytet** | Priorytet naliczania podatków i składek |
+
+### Nieobecności (`DefinicjaElementuNieobecnosciProPage`)
+
+Konfiguracja wliczania do podstaw urlopów i zasiłków:
+
+| Sekcja | Opcje |
+|---|---|
+| **Wynagrodzenia za urlop** | NieWliczać, WliczaćAktualnąWartość, WliczaćPoPrzeliczeniu, WliczaćJakZasadnicze |
+| **Wynagrodzenia za ekwiwalent** | j.w. + opcja dopełnienia |
+| **Zasiłki (pracownicy)** | NieWliczać, WliczaćDla, DopełniaćWedługGodzinDla, DopełniaćJakZasadniczeDla |
+| **Zasiłki (inni ubezpieczeni)** | j.w. |
+
+### Algorytm/Ogólne (`DefinicjaElementuAlgorytmPage`)
+
+Główna zakładka konfiguracji algorytmu — szczegóły w `references/algorytmy-naliczania.md`.
+
+### Algorytm/Edytor (`DefinicjaElementuEdytorPage`)
+
+Pole kodu C# (typ `code`) — edytor algorytmu. Aktywny gdy Algorytm = "Edytor algorytmu".
+
+### Algorytm/Podgląd (`DefinicjaElementuPodgladPage`)
+
+Podgląd wygenerowanego kodu C# (read-only).
+
+## Tworzenie nowego elementu — krok po kroku przez MCP
+
+```
+1. navigate_to_folder("Ustawienia/Kadry i płace/Płace/Elementy wynagrodzenia")
+2. add_subobject(gridID="_New_CfgDefElementowExtender_DefElementow")
+3. update_field_value — wypełnij zakładkę Ogólne (nazwa, skrót, naliczanie, lista płac)
+4. switch_form_page("DefinicjaElementuAlgorytmPage") — skonfiguruj algorytm
+5. [opcjonalnie] switch_form_page("DefinicjaElementuEdytorPage") — wpisz kod C#
+6. switch_form_page("DefinicjaElementuDeklaracjePage") — skonfiguruj PIT/ZUS
+7. switch_form_page("DefinicjaElementuNieobecnosciProPage") — skonfiguruj wliczanie do podstaw
+8. accept_subform() — zatwierdź podformularz
+9. save_form() — zapisz do bazy
+```
+
+### Wybór algorytmu
+
+| Scenariusz | Zalecany algorytm |
+|---|---|
+| Prosta kwota lub procent od zasadniczego | **Kreator algorytmu** — wystarczy ustawić Podstawę i Mnożnik |
+| Złożona logika (warunki, nietypowe obliczenia) | **Edytor algorytmu** — własny kod C# |
+| Naliczanie jak urlop/ekwiwalent | **Jak urlop wypoczynkowy** / **Jak ekwiwalent za urlop** |
+| Naliczanie za okres nieobecności | **Za okres nieobecności** |
+
+### Formatowanie kodu w edytorze (przez MCP)
+
+Znaki nowej linii w kodzie C# przez MCP wstawiamy jako `\\n`:
+
+```
+update_field_value(["_Tekst=public void Nazwa_Param(...) {\\n    ...\\n}\\n\\npublic Currency Nazwa_Wylicz(...) {\\n    return ...;\\n}"])
+```
+
+## Wskazówki przy tworzeniu nowych algorytmów
+
+1. **Wybierz wzorzec** — większość nowych elementów pasuje do jednego z istniejących wzorców. Przeczytaj `references/wzorce-algorytmiczne.md` i zacznij od skopiowania najbliższego wzorca.
+
+2. **Źródło kwoty** — zdecyduj skąd pochodzi podstawa:
+   - Kwota z parametrów pracownika → `Element.DodHistoria.Podstawa` (Wzorzec A)
+   - Kwota z konfiguracji programu → `module.Config.Zasiłki.*[Date]` (Wzorzec B)
+   - Kwota stała z definicji → `Element.Definicja.Algorytm.KreatorAlgorytmu.Podstawa` (Wzorzec C)
+   - Procent od zasadniczego → `ZasadniczeNominalne(Date)` + `Element.DodHistoria.Procent` (Wzorzec D)
+
+3. **Czas i dni** — prawie wszystkie algorytmy ustawiają czas i dni z normy:
+   ```csharp
+   CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+   Składnik.Czas = cd.Czas;
+   Składnik.Dni = cd.Dni;
+   ```
+
+4. **Pomniejszenie za nieobecności** — użyj kreatora algorytmu z konfiguracją korekt lub ręcznie: `Element.Pracownik.Czasy.Nieobecnosci(Składnik.Okres).Dni`
+
+5. **Proporcjonalność do okresu** — gdy okres składnika jest krótszy niż pełny okres naliczania, przelicz proporcjonalnie (jak w Premii procentowej — Wzorzec D).
+
+6. **Zasiłki** — zawsze używaj `new PodstawaZasiłku(Element)` i `WyliczPodstawęZasiłkuZaDzień(...)` — nie obliczaj podstawy zasiłku ręcznie.
+
+7. **Urlopy okolicznościowe** — używaj `new NaliczanieOkolicznosciowy(Element, Składnik).NaliczPodstawy()` — automatycznie ustawi Podstawa1 (za godziny) i Podstawa2 (za dni).
+
+8. **Ekwiwalenty i odprawy** — używaj `new NaliczanieEkwiwalent(Element, Składnik).NaliczPodstawy()`.
+
+9. **Element.DodHistoria.Podstawa vs Element.DodHistoria.Kwota** — w rzeczywistych algorytmach kreatorowych kwota pobierana jest z `Element.DodHistoria.Podstawa` (nie `.Kwota`). Pole `.Kwota` występuje w dokumentacji, ale `.Podstawa` jest częściej stosowane w generowanym kodzie.
+
+10. **Dodatkowe metody** — jeśli element ma odbiorców płatności (potrącenia, alimenty), zdefiniuj metody `_Odbiorca` i `_RachunekOdbiorcy`. Jeśli okres naliczania wymaga podziału, zdefiniuj `_CięcieOkresu`. Jeśli element wpływa na podstawy urlopów/zasiłków — przeczytaj `references/metody-sterujace-naliczaniem.md`.

soneta-place-def-elementow/evals/evals.json

@@ -0,0 +1,23 @@
+{
+  "skill_name": "soneta-place-def-elementow",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Napisz algorytm C# dla edytora algorytmu w enova365 — nowy element wynagrodzenia typu Dodatek o nazwie 'Premia uznaniowa'. Podstawa to kwota z parametru dodatku pracownika, bez żadnych mnożników. Element powinien mieć poprawne sygnatury metod _Param i _Wylicz.",
+      "expected_output": "Poprawny kod C# z metodami Premia_Uznaniowa_Param i Premia_Uznaniowa_Wylicz, używający WypElementDodatek w sygnaturze, pobierający kwotę z Element.DodHistoria.Podstawa (lub .Kwota), ustawiający Składnik.Podstawa1, Czas i Dni z normy",
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "Potrzebuję algorytmu C# dla elementu wynagrodzenia typu Dodatek w enova365, który oblicza premię jako 15% od wynagrodzenia zasadniczego nominalnego, z pomniejszeniem proporcjonalnym za nieobecności chorobowe. Napisz kompletny kod do edytora algorytmu.",
+      "expected_output": "Kod C# z _Param pobierającym ZasadniczeNominalne, ustawiającym Procent, obsługującym pomniejszenie za nieobecności chorobowe (przez Czasy.Nieobecnosci lub iterację po OkresNieobecności), poprawna formuła _Wylicz = Podstawa1 * Procent z korektą",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Utwórz w enova365 przez MCP nową definicję elementu wynagrodzenia — dodatek stażowy zależny od lat pracy w firmie. Opisz krok po kroku jakie operacje MCP wykonać i jaki algorytm wybrać.",
+      "expected_output": "Krokowa instrukcja MCP: navigate_to_folder, add_subobject z gridID, update_field_value na zakładce Ogólne, switch_form_page na algorytm z wyborem Kreatora, ustawienie podstawy=ZasadniczeNominalne i mnożnika=ZależnyOdStażuPracy, konfiguracja deklaracji, accept_subform, save_form",
+      "files": []
+    }
+  ]
+}

soneta-place-def-elementow/references/algorytmy-naliczania.md

@@ -0,0 +1,300 @@
+# Algorytmy naliczania — kluczowa konfiguracja
+
+## Typy algorytmów
+
+| Typ | Opis |
+|---|---|
+| **Kreator algorytmu** | Konfigurator wizualny — definiujesz podstawę, mnożnik, korekty. System generuje kod C#. |
+| **Edytor algorytmu** | Ręczny kod C# w edytorze. Pełna kontrola nad logiką. |
+| **Klasa algorytmu** | Wskazanie klasy C# z zewnętrznego assembly. |
+| **Za okres nieobecności** | Wbudowany algorytm dla nieobecności. |
+| **Jak ekwiwalent za urlop** | Wbudowany algorytm ekwiwalentu. |
+| **Jak urlop wypoczynkowy** | Wbudowany algorytm urlopu wypoczynkowego. |
+| **Jak urlop okolicznościowy** | Wbudowany algorytm urlopu okolicznościowego. |
+
+## Kreator algorytmu — parametry
+
+### Podstawa
+
+| Typ podstawy | Opis | Przykład użycia |
+|---|---|---|
+| `Kwota` | Stała kwota z parametru elementu | Premia kwotowa |
+| `Wyrażenie` | Wyrażenie C# jako podstawa | Wynagrodzenie zasadnicze |
+| `Kod metody` | Wywołanie metody C# | Zaawansowane obliczenia |
+| `ZasadniczeNominalne` | Nominalne wynagrodzenie zasadnicze | Dodatek stażowy, premia procentowa |
+| `ZasadniczeRzeczywiste` | Rzeczywiste wynagrodzenie zasadnicze | — |
+| `Brutto` | Kwota brutto wypłaty | — |
+| `BruttoBezZasiłków` | Brutto bez zasiłków | — |
+| `StawkaZaszeregowania1h` | Stawka godzinowa | Nadgodziny |
+| `PodstawaUrlopuWypoczynkowego1h` | Podstawa urlopu za 1h | — |
+| `PodstawaEkwiwalentu1h` | Podstawa ekwiwalentu za 1h | — |
+| `NajniższeWynagrodzenie1h` | Minimalna stawka za 1h | — |
+
+### Pomniejszenie za okres niezatrudnienia
+
+| Wartość | Opis |
+|---|---|
+| `NiePomniejszany` | Bez pomniejszenia |
+| `Proporcjonalnie` | Proporcjonalnie do dni zatrudnienia |
+| `JednaTrzydzista` | 1/30 za każdy dzień niezatrudnienia |
+| `DniKalendarzowe` | Wg dni kalendarzowych |
+
+### Mnożnik
+
+| Typ | Opis |
+|---|---|
+| `BezWspółczynnika` | Bez mnożnika |
+| `Procent` | Procent z parametru elementu |
+| `Ułamek` | Ułamek (np. 1/3) |
+| `Współczynnik` | Stały współczynnik |
+| `ZależnyOdStażuPracy` | Tabela procentowa wg lat stażu |
+
+### Korekta za nieobecności
+
+Dla każdego typu nieobecności oddzielnie:
+
+| Wartość | Opis |
+|---|---|
+| `NiePomniejsza` | Brak pomniejszenia |
+| `Proporcjonalnie` | Proporcjonalnie do godzin nieobecności |
+| `JednaTrzydziesta` | 1/30 za każdy dzień nieobecności |
+| `JakZasadnicze` | Tak samo jak wynagrodzenie zasadnicze |
+| `ZaKażdyDzień` | Za każdy dzień kalendarzowy |
+| `Algorytm` | Własny algorytm pomniejszenia |
+
+Typy nieobecności: nieusprawiedliwione, niepłatne, płatne (urlopy), wychowawcze, macierzyńskie, rehabilitacyjne, opiekuńcze, chorobowe.
+
+### Zależność od czasu pracy
+
+| Wartość | Opis |
+|---|---|
+| `NieZależyOdCzasu` | Bez zależności od czasu |
+| `Godzinę` | Wartość za godzinę × czas pracy |
+| `Miesięcznie` | Wartość miesięczna z korektami za nieobecności |
+
+## Edytor algorytmu — struktura kodu C#
+
+Algorytm edytora wymaga **dwóch metod publicznych**:
+
+```csharp
+// Metoda _Param — przygotowanie danych do obliczeń
+public void {Identyfikator}_Param({KlasaElementu} Element, WypSkladnik Składnik)
+{
+    // Ustaw podstawy, czas, dni, procent
+}
+
+// Metoda _Wylicz — obliczenie końcowej wartości
+public Currency {Identyfikator}_Wylicz({KlasaElementu} Element, WypSkladnik Składnik)
+{
+    // Zwróć obliczoną wartość elementu
+    return ...;
+}
+```
+
+Opcjonalna trzecia metoda (dla elementów Etat):
+```csharp
+// Metoda _Wartość1h — wartość za 1 godzinę (używana przez inne elementy)
+public double {Identyfikator}_Wartość1h({KlasaElementu} Element)
+{
+    return ...;
+}
+```
+
+### Klasy elementów wg rodzaju
+
+| Rodzaj | Klasa w sygnaturze metody |
+|---|---|
+| Etat | `Soneta.Place.WypElementEtat` |
+| Dodatek | `Soneta.Place.WypElementDodatek` |
+| Dodatek automatyczny | `Soneta.Place.WypElementDodatekAutomatyczny` |
+| Nieobecność | `Soneta.Place.WypElementNieobecnosc` |
+| Nadgodziny I/II/św | `Soneta.Place.WypElementNadgodziny` |
+| Nocne | `Soneta.Place.WypElementNocne` |
+| Umowa | `Soneta.Place.WypElementUmowa` |
+| Świadczenie | `Soneta.Place.WypElementSwiadczenie` |
+
+**Uwaga:** Klasa `WypElementDodatekAutomatyczny` jest odrębna od `WypElementDodatek` — algorytmy dodatków automatycznych muszą używać tej klasy w sygnaturze.
+
+## Przykłady kompletnych algorytmów C#
+
+### Wynagrodzenie zasadnicze miesięczne (Etat)
+
+Podstawa: wyrażenie `StawkaZaszeregowania1h * Norma.Czas`
+
+```csharp
+public void Wynagrodzenie_Zasadnicze_Mies__Param(
+    Soneta.Place.WypElementEtat Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa1 = StawkaZaszeregowania1h(Element.Okres.To)
+        * Pracownik.Czasy.Norma(Składnik.Okres).Czas;
+    Składnik.Podstawa1 = podstawa1;
+
+    CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+    Składnik.Czas = cd.Czas;
+    Składnik.Dni = cd.Dni;
+}
+
+public Currency Wynagrodzenie_Zasadnicze_Mies__Wylicz(
+    Soneta.Place.WypElementEtat Element, WypSkladnik Składnik)
+{
+    return Składnik.Podstawa1;
+}
+
+public double Wynagrodzenie_Zasadnicze_Mies__Wartość1h(
+    Soneta.Place.WypElementEtat Element)
+{
+    return Element.PrzeliczNaPln(StawkaZaszeregowania1h(Element.Okres.To)).Value;
+}
+```
+
+### Dodatek stażowy (Dodatek — zależny od stażu pracy)
+
+Podstawa: ZasadniczeNominalne, Mnożnik: ZależnyOdStażuPracy
+
+```csharp
+public void Dodatek_Stażowy_Param(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa1 = ZasadniczeNominalne(Element.Okres.To);
+    Składnik.Podstawa1 = podstawa1;
+
+    WspolczynnikDefElementu współczynnik = Element.Definicja.Algorytm.KreatorAlgorytmu.Wspolczynnik;
+    Date dataStażu = współczynnik.PracaWFirmie ? Element.Okres.To : Date.Empty;
+    int lataStażu = Element.Pracownik.StażPracy(dataStażu, współczynnik.PodstawaStazu).Lata;
+    Składnik.Procent = współczynnik[lataStażu];
+
+    CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+    Składnik.Czas = cd.Czas;
+    Składnik.Dni = cd.Dni;
+}
+
+public Currency Dodatek_Stażowy_Wylicz(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    return (Składnik.Podstawa1 * Składnik.Procent);
+}
+```
+
+### Premia procentowa (Dodatek — procent od zasadniczego)
+
+Podstawa: ZasadniczeNominalne, Mnożnik: Procent (z parametru dodatku)
+
+```csharp
+public void Premia_Procentowa_Param(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa1 = ZasadniczeNominalne(Element.Okres.To);
+    FromTo okres = PełnyOkresNaliczania(Element, Składnik);
+
+    if (okres == Składnik.Okres)
+        Składnik.Podstawa1 = podstawa1;
+    else {
+        // Przeliczenie proporcjonalne gdy okres składnika != pełny okres
+        Time tokr = Czasy.KalkPlanu.NormaWym(Fraction.One, new Time(8,0), Składnik.Okres).Czas;
+        Time tpełny = Czasy.KalkPlanu.NormaKodeksowaWym(Fraction.One, new Time(8,0), okres).Czas;
+        if (tpełny == Time.Zero)
+            Składnik.Podstawa1 = DoubleCy.Zero;
+        else if (tokr > tpełny)
+            Składnik.Podstawa1 = podstawa1;
+        else
+            Składnik.Podstawa1 = podstawa1 * tokr / tpełny;
+    }
+
+    Składnik.Procent = Element.DodHistoria.Procent;
+    CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+    Składnik.Czas = cd.Czas;
+    Składnik.Dni = cd.Dni;
+}
+
+public Currency Premia_Procentowa_Wylicz(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    return (Składnik.Podstawa1 * Składnik.Procent);
+}
+```
+
+### Premia kwotowa (Dodatek — prosta kwota)
+
+Podstawa: Kwota
+
+```csharp
+public void Premia_Param(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa1 = Element.DodHistoria.Kwota;
+    Składnik.Podstawa1 = podstawa1;
+
+    CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+    Składnik.Czas = cd.Czas;
+    Składnik.Dni = cd.Dni;
+}
+
+public Currency Premia_Wylicz(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    return Składnik.Podstawa1;
+}
+```
+
+### Dopłata do nadgodzin 50% (Nadgodziny I)
+
+Podstawa: StawkaZaszeregowania1h + wynagrodzenie za nadgodziny, Mnożnik: 50%
+
+```csharp
+public void Dopłata_Do_N_Godz_50__Param(
+    Soneta.Place.WypElementNadgodziny Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa1;
+    if (!Element.PracHistoria.Etat.WynagrodzenieAkordowe
+        || !Płace.Config.Etat.NadgodzinyAkordowe60)
+        podstawa1 = Element.PracHistoria.Etat.Kalendarz.Nadgodziny.PodstawaWgNormyKP
+            ? StawkaZaszeregowaniaNorm1h(Element.Okres.To) + WnagrodzenieZaNadgodziny(Element)
+            : StawkaZaszeregowania1h(Element.Okres.To) + WnagrodzenieZaNadgodziny(Element);
+    else
+        using (Soneta.Business.LogCatcher listener = new Soneta.Business.LogCatcher("Urlop")) {
+            using (Pracownik.Session.Logout(true)) {
+                var naliczanie = new NaliczanieWypoczynkowy(Element, Składnik);
+                naliczanie.NaliczPodstawy();
+                var procent = new Percent(0.6m);
+                podstawa1 = Składnik.Podstawa1 * procent;
+                Składnik.Podstawa1 = Składnik.Podstawa2 = DoubleCy.Zero;
+            }
+        }
+    Składnik.Podstawa1 = podstawa1;
+
+    Składnik.Procent = Element.Definicja.Algorytm.KreatorAlgorytmu.Wspolczynnik.Procent;
+    ZestawienieNadgodzin zestNad = NadgodzinyDobaOkres(Element, Składnik);
+    Składnik.Czas = zestNad.N50;
+}
+
+public Currency Dopłata_Do_N_Godz_50__Wylicz(
+    Soneta.Place.WypElementNadgodziny Element, WypSkladnik Składnik)
+{
+    return ((Currency)(Składnik.Podstawa1 * Składnik.Procent) * Składnik.Czas);
+}
+```
+
+### Potrącenie za nieobecność 1/28 (Dodatek — edytor algorytmu, niestandardowe)
+
+Podstawa: ZasadniczeNominalne, pomniejszenie o 1/28 za każdy dzień nieobecności.
+
+```csharp
+public void Potrącenie_Za_Nieobecność_1_28_Param(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    DoubleCy podstawa = ZasadniczeNominalne(Element.Okres.To);
+    Składnik.Podstawa1 = podstawa;
+
+    int dniNieobecnosci = Element.Pracownik.Czasy.Nieobecnosci(Składnik.Okres).Dni;
+    Składnik.Dni = dniNieobecnosci;
+
+    CzasDni cd = Element.Pracownik.Czasy.Norma(Składnik.Okres);
+    Składnik.Czas = cd.Czas;
+}
+
+public Currency Potrącenie_Za_Nieobecność_1_28_Wylicz(
+    Soneta.Place.WypElementDodatek Element, WypSkladnik Składnik)
+{
+    return Składnik.Podstawa1 - (Składnik.Podstawa1 * Składnik.Dni / 28);
+}
+```

soneta-place-def-elementow/references/api-algorytmow.md

@@ -0,0 +1,212 @@
+# API algorytmów — pola, metody, klasy, typy danych
+
+## Pola WypSkladnik
+
+### Podstawowe pola
+
+| Pole | Typ | Opis |
+|---|---|---|
+| `Składnik.Podstawa1` | `DoubleCy` | Główna podstawa obliczenia |
+| `Składnik.Podstawa2` | `DoubleCy` | Dodatkowa podstawa |
+| `Składnik.Czas` | `Time` | Czas pracy (godziny) |
+| `Składnik.Dni` | `int` | Liczba dni |
+| `Składnik.Procent` | `Percent` | Procent (mnożnik) |
+| `Składnik.Okres` | `FromTo` | Okres naliczania składnika |
+
+### Dodatkowe pola (odkryte w rzeczywistych algorytmach)
+
+| Pole | Typ | Opis | Przykład użycia |
+|---|---|---|---|
+| `Składnik.Podstawa3` | `DoubleCy` | Trzecia podstawa obliczenia | Wyrównanie macierzyńskiego (podstawa dzienna) |
+| `Składnik.Wspolczynnik` | `double` | Współczynnik mnożnikowy | Ryczałt samochodowy (liczba km) |
+| `Składnik.Ilosc` | `Fraction` | Ilość (wymiar etatu przy zbiegu) | `WymiarEtatuZasiłekPrzyZbiegu(Element)` |
+| `Składnik.DataKursu` | `Date` | Data kursu waluty | Przeliczanie walut w algorytmie postojowym |
+| `Składnik.Ulamek` | `Fraction` | Ułamek (wymiar etatu) | Mnożenie przez wymiar etatu |
+
+## Metody pomocnicze
+
+### Podstawowe metody
+
+| Metoda | Zwraca | Opis |
+|---|---|---|
+| `ZasadniczeNominalne(Date)` | `DoubleCy` | Nominalne wynagrodzenie zasadnicze na datę |
+| `StawkaZaszeregowania1h(Date)` | `DoubleCy` | Stawka zaszeregowania za 1 godzinę |
+| `StawkaZaszeregowaniaNorm1h(Date)` | `DoubleCy` | Stawka zaszereg. normatywna za 1h |
+| `Element.Pracownik.Czasy.Norma(FromTo)` | `CzasDni` | Norma czasu pracy (Czas + Dni) |
+| `Element.Pracownik.Czasy.Nieobecnosci(FromTo)` | `CzasDni` | Czas nieobecności (Czas + Dni) |
+| `Element.Pracownik.StażPracy(Date, PodstawaStazu)` | obiekt z `.Lata` | Staż pracy |
+| `Element.Okres` | `FromTo` | Okres elementu (.From, .To) |
+| `Element.DodHistoria.Procent` | `Percent` | Procent z parametru dodatku |
+| `Element.DodHistoria.Kwota` | `Currency` | Kwota z parametru dodatku |
+| `Element.DodHistoria.Podstawa` | `DoubleCy` | Podstawa z parametru dodatku (częściej używana niż .Kwota) |
+| `PełnyOkresNaliczania(Element, Składnik)` | `FromTo` | Pełny okres naliczania |
+| `NadgodzinyDobaOkres(Element, Składnik)` | `ZestawienieNadgodzin` | Zestawienie nadgodzin (.N50, .N100) |
+| `SumaElementow(Element, okres, WypElement.Zasadnicze)` | `DoubleCy` | Suma elementów zasadniczych |
+
+### Dodatkowe metody pomocnicze (odkryte w rzeczywistych algorytmach)
+
+| Metoda | Zwraca | Opis |
+|---|---|---|
+| `WyliczPodstawęZasiłkuZaDzień(Element, Składnik)` | `DoubleCy` | Podstawa zasiłku za 1 dzień (po waloryzacji, ograniczeniach) |
+| `OgraniczeniePodstawyZasiłkuDoKorygowanego(Element, Składnik, wartość)` | `Currency` | Ograniczenie wartości zasiłku do kwoty korygowanego |
+| `WymiarEtatuZasiłekPrzyZbiegu(Element)` | `Fraction` | Wymiar etatu dla zasiłku przy zbiegu tytułów |
+| `WnagrodzenieZaNadgodziny(Element)` | `DoubleCy` | Wynagrodzenie za nadgodziny do podstawy dopłaty |
+| `NajniższeWynagrodzenie1h(Date)` | `DoubleCy` | Minimalne wynagrodzenie za 1h |
+| `PrzeliczDniNaGodziny(Date, int)` | `Time` | Przeliczenie dni na godziny wg normy |
+| `OdsetkiZUS_ParamInt(Element, Składnik)` | `void` | Naliczenie odsetek od zasiłków ZUS |
+| `PodstawyPotrąceniaOPP(Element, Składnik)` | `void` | Naliczenie podstawy potrącenia OPP |
+| `WartośćPotrąceniaOPP(Element, Składnik)` | `Currency` | Wartość potrącenia OPP |
+| `PodstawaSkładekZUSWłaścicielaWakacjeSkładkowe(Element)` | `DoubleCy` | Podstawa składek z uwzgl. wakacji składkowych |
+| `WartośćZasiłku(Element, Składnik, kwota)` | `DoubleCy` | Wartość zasiłku proporcjonalna do okresu |
+| `NettoBrutto(Element, wartość)` | `DoubleCy` | Przeliczenie netto na brutto |
+| `SpłataZaliczkiNieopodatkowanej(Element, Składnik)` | `DoubleCy` | Spłata zaliczki nieopodatkowanej |
+| `WartośćWskaźnika(string nazwa, Date data)` | `DoubleCy` | Wartość wskaźnika |
+| `WartośćWskaźnikaObj(string nazwa, Date data)` | `object` | Wartość wskaźnika jako obiekt (do castowania) |
+
+## Klasy i obiekty dostępne w algorytmach
+
+| Klasa / Obiekt | Opis | Przykład dostępu |
+|---|---|---|
+| `PodstawaZasiłku` | Wylicza podstawę zasiłku chorobowego/macierzyńskiego — `Podstawa`, `Procent` | `new PodstawaZasiłku(Element)` |
+| `NaliczanieOkolicznosciowy` | Nalicza wynagrodzenie za urlopy okolicznościowe, delegacje itp. | `new NaliczanieOkolicznosciowy(Element, Składnik).NaliczPodstawy()` |
+| `NaliczanieEkwiwalent` | Nalicza podstawę ekwiwalentu za urlop | `new NaliczanieEkwiwalent(Element, Składnik).NaliczPodstawy()` |
+| `NaliczanieWypoczynkowy` | Nalicza podstawę urlopu wypoczynkowego (używane w nadgodzinach akordowych) | `new NaliczanieWypoczynkowy(Element, Składnik).NaliczPodstawy()` |
+| `PodwyższenieMacierzyńskiego` | Nalicza wyrównanie zasiłku macierzyńskiego | `new PodwyższenieMacierzyńskiego(Element, Składnik).NaliczPodstawy()` |
+| `JakEkwiwalentZaUrlop` | Klasa statyczna z metodami kontroli ekwiwalentu | `JakEkwiwalentZaUrlop.KontrolaPrzeliczeniaLimitu(...)` |
+| `PlaceModule` | Moduł płac — dostęp do konfiguracji | `Element.Table.Module` lub `Element.Module` |
+| `KalendModule` | Moduł kalendarza — strefy, limity nieobecności | `KalendModule.GetInstance(Element)` |
+| `SamochodowkaModule` | Moduł samochodówki — stawki za km | `SamochodowkaModule.GetInstance(Element)` |
+| `KadryModule` | Moduł kadr — podstawy stażu | `KadryModule.GetInstance(Element)` |
+| `DefinicjaStrefy` | Definicja strefy czasu pracy | `KalendModule.GetInstance(Element).DefinicjeStref.WgNazwy["Praca zdalna"]` |
+| `DefinicjaStrefy.PrzestójEkonomiczny` | Predefiniowana strefa przestoju ekonomicznego | `Kalend.DefinicjeStref[DefinicjaStrefy.PrzestójEkonomiczny]` |
+| `DefinicjaStrefy.PrzestójKP` | Predefiniowana strefa przestoju KP | `Kalend.DefinicjeStref[DefinicjaStrefy.PrzestójKP]` |
+| `LimitNieobecnosci` | Limit urlopowy pracownika | `KalendModule.GetInstance(Element).LimNieobecnosci.WgPracownik[...]` |
+| `DefinicjaLimitu` | Definicja limitu (np. urlop wypoczynkowy) | `KalendModule.GetInstance(Element).DefinicjeLimitow.UrlopWypoczynkowy` |
+| `CzlonekRodziny` | Członek rodziny pracownika | `Element.Dodatek.Rodzina` |
+
+### Dostęp do konfiguracji
+
+| Ścieżka | Opis | Przykład |
+|---|---|---|
+| `module.Config.Zasiłki.*[Date]` | Kwoty zasiłków indeksowane datą | `module.Config.Zasiłki.Pielęgnacyjny[Element.Okres.To]` |
+| `module.Config.PracaZdalna.*[Date]` | Stawki pracy zdalnej | `Element.Module.Config.PracaZdalna.StawkaGodzinowa[Element.Okres.To]` |
+| `Płace.Config.Etat.*` | Konfiguracja etatowa (nadgodziny akordowe) | `Płace.Config.Etat.NadgodzinyAkordowe60` |
+| `Płace.Config.Ogólne.*` | Konfiguracja ogólna płac | `Płace.Config.Ogólne.PrzestójWPodstawieMinimalnejPłacy` |
+| `SamochodowkaModule.Config.StawkiZaKm.*[Date]` | Stawki za km | `sm.Config.StawkiZaKm.SamochodDo900[Element.Okres.To]` |
+
+## Typy danych
+
+| Typ | Opis |
+|---|---|
+| `Currency` | Wartość pieniężna (z walutą) — typ zwracany przez _Wylicz |
+| `DoubleCy` | Wartość zmiennoprzecinkowa z walutą — do obliczeń pośrednich |
+| `Time` | Czas (godziny:minuty) |
+| `Date` | Data |
+| `FromTo` | Zakres dat (From..To) |
+| `Percent` | Wartość procentowa |
+| `Fraction` | Ułamek (np. wymiar etatu), z polami `.Num` i `.Den` |
+| `CzasDni` | Struktura z polami .Czas (Time) i .Dni (int) |
+| `YearMonth` | Rok + miesiąc, z właściwością .Days |
+
+## Operacje na typach danych
+
+| Operacja | Składnia | Opis |
+|---|---|---|
+| Zaokrąglenie w górę | `wartość.Ceiling(1)` | Zaokrąglenie Currency/DoubleCy w górę do 1 miejsca |
+| Maximum z dwóch wartości | `DoubleCy.Max(a, b)` | Większa z dwóch wartości DoubleCy |
+| Stała zero | `DoubleCy.Zero` | Wartość zerowa DoubleCy |
+| Czas zero | `Time.Zero` | Czas zerowy |
+| Czas pusty | `Time.Empty` | Czas niezainicjalizowany |
+| Sprawdzenie czasu | `Time.ZeroOrEmpty(czas)` | Czy czas jest zerowy lub pusty |
+| Maksimum czasu | `Time.Max(a, b)` | Większy z dwóch czasów |
+| Rzutowanie | `(Currency)doubleCy` | Konwersja DoubleCy → Currency |
+| Rzutowanie | `(decimal)doubleCy.Value` | Konwersja DoubleCy → decimal |
+| Pełny miesiąc | `Składnik.Okres.FullMonth` | Rozszerzenie okresu do pełnego miesiąca |
+| Dni w miesiącu | `FromTo.Month(date).Days` | Liczba dni w miesiącu zawierającym datę |
+| Pierwszy dzień | `date.FirstDayMonth()` | Pierwszy dzień miesiąca |
+| Wiek | `new FromTo(from, to).Age` | Obliczenie pełnych lat między datami |
+| Przeliczenie waluty | `Element.PrzeliczNaPln(doubleCy)` | Przeliczenie na PLN |
+| Tabela kursowa | `Pracownik.GetTabelaKursowa(date)` | Pobranie tabeli kursowej |
+| Przeliczenie walut | `tabela.Przelicz(wartość, date, symbol)` | Przeliczenie między walutami |
+| Max/Min Currency | `Currency.Max(a, b)` / `Currency.Min(a, b)` | Porównanie wartości Currency |
+| Zaokrąglenie | `wartość.Round(0)` | Zaokrąglenie do pełnych złotych |
+| Zaokrąglenie DoubleCy | `new DoubleCy(Soneta.Tools.Math.Round(val.Value, 1), val.Symbol)` | Zaokrąglenie DoubleCy do 1 miejsca |
+
+## Sygnatury metod algorytmu
+
+### Metody obowiązkowe
+
+```csharp
+// _Param — przygotowanie danych
+public void {Identyfikator}_Param({KlasaElementu} Element, WypSkladnik Składnik) { }
+
+// _Wylicz — obliczenie wartości
+public Currency {Identyfikator}_Wylicz({KlasaElementu} Element, WypSkladnik Składnik) { return ...; }
+```
+
+### Metody opcjonalne
+
+```csharp
+// _Wartość1h — wartość za 1 godzinę (dla elementów Etat)
+public double {Identyfikator}_Wartość1h({KlasaElementu} Element) { return ...; }
+
+// _Odbiorca — ustalenie odbiorcy płatności (np. dla potrąceń OPP, alimentów)
+public IPodmiotKasowy {Identyfikator}_Odbiorca({KlasaElementu} Element)
+{
+    return Element.PracHistoria.OdpisOPP.Organizacja;
+}
+
+// _RachunekOdbiorcy — rachunek bankowy odbiorcy
+public RachunekBankowyPodmiotu {Identyfikator}_RachunekOdbiorcy(
+    {KlasaElementu} Element, IPodmiotKasowy odbiorca)
+{
+    return odbiorca == null ? null : odbiorca.DomyslnyRachunek;
+}
+
+// _CięcieOkresu — podział okresu naliczania na podokresy
+public Periods {Identyfikator}_CięcieOkresu({KlasaElementu} Element, Periods periods)
+{
+    return ...; // zwraca podzielone okresy
+}
+
+// _Podstawa — dodatkowa metoda obliczania podstawy
+public DoubleCy {Identyfikator}_Podstawa({KlasaElementu} Element, WypSkladnik Składnik)
+{
+    return ...; // obliczona podstawa
+}
+```
+
+### Klasy elementów wg rodzaju (do użycia w sygnaturze)
+
+| Rodzaj | Klasa |
+|---|---|
+| Etat | `Soneta.Place.WypElementEtat` |
+| Dodatek | `Soneta.Place.WypElementDodatek` |
+| Dodatek automatyczny | `Soneta.Place.WypElementDodatekAutomatyczny` |
+| Nieobecność | `Soneta.Place.WypElementNieobecnosc` |
+| Nadgodziny I/II/św | `Soneta.Place.WypElementNadgodziny` |
+| Nocne | `Soneta.Place.WypElementNocne` |
+| Umowa | `Soneta.Place.WypElementUmowa` |
+| Świadczenie | `Soneta.Place.WypElementSwiadczenie` |
+
+## Dostępne wartości enumeracji
+
+### RodzajŹródłaWypłaty
+
+`Etat`, `Nieobecność`, `Umowa`, `Akord`, `Storno`, `Dodatek`, `NadgodzinyI`, `NadgodzinyII`, `NadgodzinyŚw`, `Nocne`, `Kurs`, `Świadczenie`, `Nagroda`, `Kara`, `FundPożWpisowe`, `FundPożWycofanie`, `FundPożSkładka`, `Pożyczka`, `PożyczkaSpłata`, `Zaliczka`, `SpłataZaliczki`
+
+### TypNieobecnosci
+
+`UsprawiedliwionaPłatna`, `NieobecnośćZUS` i inne.
+
+### PrzyczynaNieobecnosci
+
+`UrlopWypoczynkowy`, `ZwolnienieChorobowe` i inne.
+
+### RodzajStawkiZaszeregowania
+
+`Miesieczna`, `Godzinowa`
+
+### TypUbezpieczeniaSpolecznego
+
+`NieNaliczać` i inne.

soneta-place-def-elementow/references/metody-sterujace-naliczaniem.md

@@ -0,0 +1,56 @@
+# Dodatkowe sygnatury metod sterujących naliczaniem
+
+Oprócz standardowych metod `_Param`, `_Wylicz`, `_Wartość1h`, `_Odbiorca`, `_RachunekOdbiorcy` i `_CięcieOkresu`, algorytm edytora może definiować metody wpływające na podstawy urlopów i zasiłków.
+
+## _PodstawaUrlopu — sterowanie podstawą urlopu
+
+Metoda wywoływana przez system przy naliczaniu urlopu wypoczynkowego, gdy element powinien być wliczany do podstawy urlopu w niestandardowy sposób:
+
+```csharp
+public decimal {Identyfikator}_PodstawaUrlopu(WypElement Urlop, WypElement Element) {
+    var wymiar = Element.PracHistoria.Etat.Zaszeregowanie.Wymiar;
+    var mies = new YearMonth(Element.Okres.To);
+    var normamies = Czasy.KalkPlanu.NormaWym(wymiar, mies).Czas.TotalMinutes;
+    var norma = Czasy.KalkPlanu.NormaWym(wymiar, Element.Okres).Czas.TotalMinutes;
+
+    decimal podstawa = (decimal)ZasadniczeNominalne(Element.Okres.To).Value;
+    Percent proc = Element.SkładnikGłówny.Procent;
+
+    return podstawa * proc * norma / normamies;
+}
+```
+
+## _PodstawaZasiłku — sterowanie podstawą zasiłków ZUS
+
+Metoda wywoływana przy naliczaniu zasiłków chorobowych, macierzyńskich itp., gdy element powinien być wliczany do podstawy zasiłku w niestandardowy sposób:
+
+### Wariant prosty — stała kwota
+
+```csharp
+public void {Identyfikator}_PodstawaZasiłku(WypElement element, PodstawaZasiłkuArgs args) {
+    args.KwotaPodstawy = 1000;
+    args.SposóbWliczenia = ElementPodstawyZasilku.SposóbWliczenia.BezDopełniania;
+}
+```
+
+### Wariant złożony — z obliczeniem
+
+```csharp
+public void {Identyfikator}_PodstawaZasiłku(WypElement element, PodstawaZasiłkuArgs args) {
+    DoubleCy podstawa = ZasadniczeNominalne(element.Okres.To);
+    foreach (WypElement e in element.Elementy[element.Okres])
+        if (e.Definicja.Nazwa == "Przestój.")
+            podstawa -= e.Wartosc;
+
+    podstawa *= 0.8629;
+    args.KwotaPodstawy = (decimal)podstawa.Value;
+    args.SposóbWliczenia = ElementPodstawyZasilku.SposóbWliczenia.BezDopełniania;
+}
+```
+
+## Klasa PodstawaZasiłkuArgs
+
+| Pole | Typ | Opis |
+|---|---|---|
+| `args.KwotaPodstawy` | `decimal` | Kwota wliczana do podstawy zasiłku |
+| `args.SposóbWliczenia` | `ElementPodstawyZasilku.SposóbWliczenia` | Sposób wliczenia (`BezDopełniania` i inne) |

soneta-place-def-elementow/references/receptury-kodu.md

@@ -0,0 +1,738 @@
+# Receptury kodu — typowe konstrukcje w algorytmach C#
+
+Gotowe fragmenty kodu C# do użycia w edytorze algorytmu. Każda receptura rozwiązuje konkretny problem obliczeniowy.
+
+## Spis treści
+
+1. [Iterowanie po elementach wypłaty](#1-iterowanie-po-elementach-wypłaty)
+2. [Wynagrodzenie zasadnicze](#2-wynagrodzenie-zasadnicze)
+3. [Nieobecności](#3-nieobecności)
+4. [Wymiar etatu](#4-wymiar-etatu)
+5. [Czas pracy i kalendarz](#5-czas-pracy-i-kalendarz)
+6. [Okresy i daty](#6-okresy-i-daty)
+7. [Staż pracy](#7-staż-pracy)
+8. [Cechy pracownika (Features)](#8-cechy-pracownika-features)
+9. [Wskaźniki](#9-wskaźniki)
+10. [Parametry dodatku pracownika (DodHistoria)](#10-parametry-dodatku-pracownika-dodhistoria)
+11. [Zaokrąglenia](#11-zaokrąglenia)
+12. [Dzielenie z zachowaniem waluty](#12-dzielenie-z-zachowaniem-waluty)
+13. [Mnożenie procentu](#13-mnożenie-procentu)
+14. [Podatki — mnożnik kosztów i ulgi](#14-podatki)
+15. [Przeliczenie Netto → Brutto](#15-przeliczenie-netto-brutto)
+16. [Naliczanie urlopów i ekwiwalentów](#16-naliczanie-urlopów-i-ekwiwalentów)
+17. [Porównywanie wartości (Max, Min)](#17-porównywanie-wartości)
+18. [Porównywanie fragmentu nazwy](#18-porównywanie-fragmentu-nazwy)
+19. [Suma czasu pracy w wydziale](#19-suma-czasu-pracy-w-wydziale)
+20. [Stawka za km (moduł samochodówki)](#20-stawka-za-km)
+21. [Pomniejszenie akordowe](#21-pomniejszenie-akordowe)
+22. [Debugowanie i logowanie](#22-debugowanie-i-logowanie)
+23. [Sprawdzenie czy pracownik ma akord](#23-sprawdzenie-akordu)
+24. [Zaliczka a spłata zaliczki — wydział](#24-zaliczka-wydział)
+
+---
+
+## 1. Iterowanie po elementach wypłaty
+
+### Odczytanie wartości z innego elementu (wg nazwy)
+
+```csharp
+Składnik.Procent = Percent.Zero;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.SkładnikGłówny != null)
+        if (e.Definicja.Nazwa == "Premia procentowa")
+            Składnik.Procent = e.SkładnikGłówny.Procent;
+```
+
+### Odczytanie wartości z innego elementu (wg Guid definicji)
+
+```csharp
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.Definicja.Guid == new Guid("xxxx-xxxxxx-xxxxxx-xxxx"))
+        // operacja na elemencie
+```
+
+### Suma elementów o wskazanej nazwie
+
+```csharp
+decimal Funkcyjny = 0m;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.Definicja.Nazwa == "Dodatek funkcyjny")
+        Funkcyjny += e.Wartosc;
+```
+
+### Suma elementów wchodzących do podstawy urlopu
+
+```csharp
+decimal Suma = 0m;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.Definicja.Nieobecnosci.Urlop.Typ != 0)
+        Suma += e.Wartosc;
+```
+
+### Suma elementów o określonym źródle (RodzajŹródłaWypłaty)
+
+```csharp
+decimal akt = 0m;
+foreach (WypElement e in Element.Elementy[Składnik.Okres])
+    if (e.RodzajZrodla == RodzajŹródłaWypłaty.Umowa)
+        akt += e.Wartosc;
+```
+
+### Suma elementów stanowiących podstawę składek ZUS
+
+```csharp
+decimal podstawa = 0m;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.Definicja.Deklaracje.Spoleczne.Typ != TypUbezpieczeniaSpolecznego.NieNaliczać)
+        podstawa += e.Wartosc;
+```
+
+### Suma elementów wg daty wypłaty (np. do 13-tki)
+
+```csharp
+FromTo okres = new Okres(Element.Okres).Rok(0);
+Soneta.Business.SubTable st = Płace.WypElementy.WgDaty[Pracownik];
+st = new Soneta.Business.SubTable(st, okres);
+
+foreach (WypElement e in st)
+    if (e is WypElementEtat)
+        Składnik.Podstawa1 += e.Wartosc;
+    else if (e.Definicja.Features.GetBool("Podstawa13"))
+        Składnik.Podstawa2 += e.Wartosc;
+```
+
+### Suma wynagrodzeń akordowych
+
+```csharp
+decimal WynagrAkordowe = 0m;
+foreach (WypElement e in Element.Elementy[Składnik.Okres])
+    if (e is WypElementAkord)
+        WynagrAkordowe += e.Wartosc;
+```
+
+### Konstrukcja switch/case po nazwach elementów
+
+```csharp
+decimal Suma = 0m;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    switch (e.Definicja.Nazwa) {
+        case "Dodatek funkcyjny":
+            Suma += e.Podatki.ZalFIS;
+            break;
+        case "Premia":
+        case "Dodatek stażowy":
+            Suma += e.Wartosc;
+            // Suma += e.Podatki.KosztyZUS;
+            // Suma += e.Netto;
+            // Suma += e.DoWypłaty;
+            break;
+    }
+```
+
+---
+
+## 2. Wynagrodzenie zasadnicze
+
+### Wynagrodzenie zasadnicze nominalne (cięte okresami aktualizacji)
+
+```csharp
+Time NormaOkres = Czasy.Norma(Składnik.Okres).Czas;
+Time NormaMies = Czasy.Norma(Składnik.Okres.FullMonth).Czas;
+
+DoubleCy Podstawa = ZasadniczeNominalne(Element.Okres.To);
+Składnik.Podstawa1 = Podstawa * NormaOkres / NormaMies;
+```
+
+### Suma elementów zasadniczych (dwie metody)
+
+```csharp
+// Metoda 1: SumaElementow
+Składnik.Podstawa1 = SumaElementow(Element, Składnik.Okres, WypElement.Zasadnicze);
+
+// Metoda 2: ZasadniczeNominalne
+Składnik.Podstawa1 = ZasadniczeNominalne(Element.Okres.To);
+```
+
+### Zależność od rodzaju stawki zaszeregowania
+
+```csharp
+if (Element.PracHistoria.Etat.Zaszeregowanie.RodzajStawki == RodzajStawkiZaszeregowania.Miesieczna) {
+    Składnik.Podstawa1 = Element.DodHistoria.Podstawa;
+} else {
+    Składnik.Podstawa1 = SumaElementow(Element, Składnik.Okres, WypElement.Zasadnicze);
+    Składnik.Procent = Element.DodHistoria.Procent;
+}
+```
+
+---
+
+## 3. Nieobecności
+
+### Liczba dni nieobecności o wskazanej nazwie
+
+```csharp
+int DniNie = 0;
+foreach (OkresNieobecności n in Pracownik.Czasy.Nieobecnosci(Element.Okres, true))
+    if (n.Definicja.Nazwa == "Urlop opiekuńczy (art 188 kp)")
+        DniNie += n.Norma().Dni;
+
+// Kalendarzowa liczba dni nieobecności:
+//     DniNie += n.Okres.Days;
+```
+
+### Liczba dni nieobecności wg typu
+
+```csharp
+Składnik.Dni = 0;
+foreach (OkresNieobecności n in Pracownik.Czasy.Nieobecnosci(Element.Okres, true))
+    if (n.Definicja.Typ != TypNieobecnosci.UsprawiedliwionaPłatna)
+        Składnik.Dni += n.Norma().Dni;
+```
+
+### Odwołanie do nieobecności z elementu wynagrodzenia
+
+```csharp
+foreach (WypElement e in Pracownik.Elementy[Element.Okres]) {
+    var en = e as WypElementNieobecność;
+    Nieobecnosc n = en == null ? null : en.Nieobecność;
+
+    if (e.Definicja.Nazwa == "Wynagr.urlop wypoczynkowy")
+        Msg(e.Okres + " / " + e.SkładnikGłówny.Podstawa1 + " / " + n.Okres);
+}
+```
+
+### Pomniejszenie wynagrodzenia zasadniczego o daną nieobecność
+
+```csharp
+decimal Pomniejszenia = 0;
+foreach (WypElement element in Element.Elementy[Składnik.Okres.FullMonth, WypElement.Zasadnicze])
+    foreach (WypSkladnik składnik in element.Skladniki) {
+        WypSkladnikPomniejszenie pomniejszenie = składnik as WypSkladnikPomniejszenie;
+        Nieobecnosc nieobecność = pomniejszenie == null ? null : pomniejszenie.Nieobecnosc;
+        if (nieobecność == Element.Nieobecność)
+            Pomniejszenia += składnik.Wartosc;
+    }
+Składnik.Podstawa1 = -Pomniejszenia;
+```
+
+### Pomniejszenia za nieobecności płatne (z elementu zasadniczego)
+
+```csharp
+decimal pomniejszenia = 0;
+foreach (WypElement element in Element.Elementy[Składnik.Okres, WypElement.Zasadnicze])
+    foreach (WypSkladnik składnik in element.Skladniki) {
+        WypSkladnikPomniejszenie pomniejszenie = składnik as WypSkladnikPomniejszenie;
+        Nieobecnosc nieobecność = pomniejszenie == null ? null : pomniejszenie.Nieobecnosc;
+        if (nieobecność != null && nieobecność.Definicja.Typ == TypNieobecnosci.UsprawiedliwionaPłatna)
+            pomniejszenia += składnik.Wartosc;
+    }
+Składnik.Podstawa1 = pomniejszenia;
+```
+
+### Sumowanie pomniejszeń z konkretnego elementu wg typu nieobecności
+
+```csharp
+decimal podstawa = 0;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.Definicja.Nazwa == "Dodatek stażowy")
+        foreach (WypSkladnik skl in e.Skladniki) {
+            Nieobecnosc n = skl.Nieobecnosc;
+            if (n != null && n.Definicja.Typ == TypNieobecnosci.NieobecnośćZUS)
+                podstawa -= skl.Wartosc;
+        }
+Składnik.Podstawa1 = podstawa;
+```
+
+---
+
+## 4. Wymiar etatu
+
+### Przeliczenie przez wymiar etatu (Num/Den)
+
+```csharp
+Składnik.Podstawa1 = ZasadniczeNominalne(Element.Okres.To);
+// Dzielenie: pełny etat → niepełny (np. 1/2 etatu: Den=2, Num=1)
+Składnik.Podstawa1 *= Element.PracHistoria.Etat.Wymiar.Den;
+Składnik.Podstawa1 /= Element.PracHistoria.Etat.Wymiar.Num;
+```
+
+### Mnożenie przez wymiar etatu (jako ułamek)
+
+```csharp
+Składnik.Ulamek = Element.PracHistoria.Etat.Wymiar;
+Składnik.Podstawa1 *= Składnik.Ulamek;
+```
+
+### Odczytanie historycznego wymiaru etatu
+
+```csharp
+int Mianownik = Element.Pracownik[Element.Data].Etat.Wymiar.Den;
+int Licznik = Element.Pracownik[Element.Data].Etat.Wymiar.Num;
+```
+
+---
+
+## 5. Czas pracy i kalendarz
+
+### Norma czasu pracy w niedziele
+
+```csharp
+KalkulatorPlanu Kalk = Czasy.KalkPlanu;
+Kalk.LoadOkres(Składnik.Okres);
+Time Norma = Time.Zero;
+foreach (Date Data in Składnik.Okres)
+    if (Data.DayOfWeek == DayOfWeek.Sunday) {
+        Dzien DzieńPlanu = Kalk[Data];
+        Norma += DzieńPlanu.Czas;
+    }
+```
+
+### Czas pracy w soboty, święta i w nocy
+
+```csharp
+// Czas w święta lub dni wolne
+CzasDni cd = Element.Pracownik.Czasy.KalkPracy.Praca(Składnik.Okres, Dzien.Świąteczny);
+CzasDni cd = Element.Pracownik.Czasy.KalkPracy.Praca(Składnik.Okres, Dzien.Wolny);
+Składnik.Czas = cd.Czas;
+Składnik.Dni = cd.Dni;
+
+// Czas pracy w soboty z nocnymi
+Time CzasPraca = Time.Zero;
+Time CzasPracaNoc = Time.Zero;
+KalkulatorPracy Kalk = Czasy.KalkPracy;
+Kalk.LoadOkres(Składnik.Okres);
+foreach (Date Data in Składnik.Okres)
+    if (Data.DayOfWeek == DayOfWeek.Saturday) {
+        Dzien DzieńPracy = Kalk[Data];
+        CzasPraca += DzieńPracy.Czas;
+        FromTo Okres = new FromTo(Data, Data);
+        CzasPracaNoc = Element.Pracownik.Czasy.Nocne(Okres);
+    }
+```
+
+### Odwołanie do strefy czasu pracy
+
+```csharp
+DefinicjaStrefy defStrefy = Kalend.DefinicjeStref.WgNazwy["Badania lekarskie"];
+CzasDni cd = Pracownik.Czasy.KalkPracy.Praca(Element.Okres, defStrefy);
+Time CzasBadania = cd.Czas;
+int DniBadania = cd.Dni;
+```
+
+### Odwołanie do standardowego kalendarza
+
+```csharp
+// Standardowy kalendarz
+Kalendarz Std = Kalend.Kalendarze.Standard;
+KalkulatorKalendarza KK = new KalkulatorKalendarza(Std);
+Time CzasNorma = KK.Norma(Składnik.Okres, null).Czas;
+
+// Kalendarz wg nazwy
+Kalendarz Std = (Kalendarz)Kalend.Kalendarze.WgNazwy[TypKalendarza.Kalendarz, "Standard"];
+
+// Kalendarz pracownika
+Kalendarz Std = Element.PracHistoria.Etat.Kalendarz;
+```
+
+### Odchyłki czasu pracy
+
+```csharp
+Odchylka odchylka = Element.Pracownik.Czasy.KalkPracy.Odchylki(Składnik.Okres);
+Składnik.Czas = odchylka.Plus - odchylka.Minus;
+// lub tylko akordy:
+Składnik.Czas = odchylka.Akordy;
+```
+
+### Dzielenie przez czas
+
+```csharp
+Time CzasPraca = Pracownik.Czasy.Praca(Element.Okres).Czas;
+double Norma = 168.0;
+Percent Prct = new Percent((decimal)(-(1 - CzasPraca.TotalHours / Norma)));
+```
+
+---
+
+## 6. Okresy i daty
+
+### Tworzenie dat i okresów
+
+```csharp
+int Rok = Element.Okres.To.Year;
+Date Data = new Date(Rok, 01, 02);
+
+// Okres ręczny
+FromTo Okres = new FromTo(new Date(Rok, 1, 1), new Date(Rok, 1, 31));
+
+// Okres od początku roku do miesiąca poprzedzającego
+int Miesiac = Element.Okres.From.Month;
+if (Miesiac > 1)
+    Okres = new FromTo(new Date(Rok, 1, 1), new Date(Rok, Miesiac, 1) - 1);
+```
+
+### Operacje na YearMonth
+
+```csharp
+YearMonth Aktualny = Składnik.Okres.ToYearMonth();
+// Okres 3 miesięcy wstecz
+FromTo Okres3Mies = new FromTo(Aktualny.AddMonths(-3).FirstDay, Aktualny.AddMonths(-1).LastDay);
+```
+
+### Liczba dni kalendarzowych
+
+```csharp
+int dniKalendarzowe = new YearMonth(Element.Okres.To).Days;
+// lub:
+int dniKalendarzowe = Element.Okres.FullMonth.Days;
+
+// Dni zatrudnienia w okresie
+int DniZatrKalend = (Element.Okres * Element.PracHistoria.Etat.OkresZatrudnienia).Days;
+```
+
+### Pętla po miesiącach (dodatki okresowe)
+
+```csharp
+int LiczMies = 0;
+DoubleCy Suma = 0.0m;
+Periods ps = Periods.New(Element.Okres).BreakByMonth();
+foreach (FromTo OkresMsc in ps) {
+    if (Czasy.Praca(OkresMsc).Dni > 0) {
+        Suma += WartośćWskaźnika("Ekwiwalent za pranie", OkresMsc.To);
+        ++LiczMies;
+    }
+}
+Składnik.Podstawa1 = Suma;
+Składnik.Dni = LiczMies;
+```
+
+### Liczba miesięcy w okresie
+
+```csharp
+Periods ps = Periods.New(Element.Okres).BreakByMonth();
+Składnik.Ilosc = ps.Count;
+```
+
+### Okres ograniczony okresem przyznania dodatku
+
+```csharp
+Time CzasNormaOkres = Czasy.Norma(Element.DodHistoria.Okres * Element.Okres).Czas;
+```
+
+### Pełny miesiąc kalendarzowy z daty
+
+```csharp
+Date dataStażu = Element.Okres.FullMonth.To;
+```
+
+---
+
+## 7. Staż pracy
+
+### Staż wg różnych podstaw
+
+```csharp
+Date DataStażu = Element.Okres.From;
+
+// Staż razem (wg zdefiniowanej podstawy)
+DefPodstawyStazu podstawaStażu
+    = KadryModule.GetInstance(Element).DefPodstawStazu.WgNazwy["Zatrudnienie poza firmą"];
+int StażRazem = Element.Pracownik.StażPracy(DataStażu, podstawaStażu).Lata;
+
+// Staż w firmie
+int StażFirma = Pracownik.StażPracy(DataStażu).Lata;
+
+// Staż poza firmą (zatrudnienie)
+int StażPoza = Pracownik.StażPracy(Kadry.DefPodstawStazu.Zatrudnienie).Lata;
+```
+
+### Wyliczanie stażu z dowolnego okresu
+
+```csharp
+StazPracy Staz = new StazPracy(Okres);
+int LataStaz = Staz.Normalizuj().Lata;
+```
+
+---
+
+## 8. Cechy pracownika (Features)
+
+### Odczyt cechy historycznej
+
+```csharp
+Date Data = Element.Okres.From;
+Time CzasNoc = (Time)Element.Pracownik.Features["Czas pracy w nocy", Data];
+Decimal Skladnik = (Decimal)Element.Pracownik.Features["Składnik", Data];
+```
+
+### Odczyt cechy niehistorycznej (typowanej)
+
+```csharp
+Składnik.Procent = Element.Pracownik.Features.GetPercent("Procent dodatku za noce");
+Składnik.Czas = Element.Pracownik.Features.GetTime("Czas pracy w nocy");
+```
+
+### Sumowanie wartości cechy historycznej w okresie
+
+```csharp
+Currency Suma = 0;
+Soneta.Business.HistoryFeature Premie = (Soneta.Business.HistoryFeature)Pracownik.Features["Premia"];
+foreach (Date Data in Premie.Dates)
+    if (Okres.Contains(Data)) {
+        Currency Premia = Premie.GetCurrency(Data);
+        // lub: Decimal Premia = Premie.GetDecimal(Data);
+        Suma += Premia;
+    }
+```
+
+---
+
+## 9. Wskaźniki
+
+### Odczytanie wartości wskaźnika
+
+```csharp
+DoubleCy wartość = WartośćWskaźnika("Ekwiwalent za pranie", Element.Okres.To);
+```
+
+### Odczytanie wskaźnika jako obiektu (do dzielenia, castowania)
+
+```csharp
+Składnik.Ilosc = (double)WartośćWskaźnikaObj("Współczynnik nagrody", Składnik.Okres.To);
+```
+
+### Sklejanie nazwy wskaźnika z danymi pracownika
+
+```csharp
+DoubleCy Obrót = WartośćWskaźnika("Obrót " + Wydział.Nazwa, Element.Okres.To);
+// lub ze stanowiskiem:
+DoubleCy Podstawa = WartośćWskaźnika(
+    "Narzędzia /" + Element.Pracownik[OkresMsc.To].Etat.Stanowisko.ToLower(),
+    OkresMsc.To);
+```
+
+---
+
+## 10. Parametry dodatku pracownika (DodHistoria)
+
+### Odczytanie kwoty i procentu z dodatku
+
+```csharp
+Składnik.Podstawa1 = Element.DodHistoria.Podstawa;
+Składnik.Procent = Element.DodHistoria.Procent;
+```
+
+### Iterowanie po historii dodatku
+
+```csharp
+// Wariant 1: po dodatkach pracownika
+Składnik.Podstawa1 = 0.0m;
+foreach (Dodatek d in Pracownik.Dodatki) {
+    DodHistoria dh = d[Element.Okres.From];
+    if (dh.Element.Nazwa == "Premia") {
+        Składnik.Podstawa1 = dh.Podstawa;
+        break;
+    }
+}
+
+// Wariant 2: po historii jednego dodatku (sumowanie w okresie)
+YearMonth Aktualny = Składnik.Okres.ToYearMonth();
+FromTo okres = new FromTo(Aktualny.AddMonths(-2).FirstDay, Aktualny.AddMonths(0).LastDay);
+Currency suma = 0;
+foreach (DodHistoria dh in Element.Dodatek.Historia)
+    if (okres.Contains(dh.Aktualnosc.From))
+        suma += dh.Podstawa;
+```
+
+---
+
+## 11. Zaokrąglenia
+
+```csharp
+// Zaokrąglenie DoubleCy do 1 miejsca po przecinku
+DoubleCy TmpCy = Składnik.Podstawa1;
+Składnik.Podstawa1 = new DoubleCy(Soneta.Tools.Math.Round(TmpCy.Value, 1), TmpCy.Symbol);
+
+// Zaokrąglenie wyniku (Currency) do pełnych złotych
+return Składnik.Podstawa1.Round(0);
+
+// Zaokrąglenie w górę
+return Składnik.Podstawa1.Ceiling(1);
+```
+
+---
+
+## 12. Dzielenie z zachowaniem waluty
+
+```csharp
+Składnik.Ilosc = (double)WartośćWskaźnikaObj("Współczynnik nagrody", Składnik.Okres.To);
+DoubleCy w = Składnik.Podstawa1 * Składnik.Dni * Składnik.Procent;
+return new DoubleCy(w.Value / Składnik.Ilosc, w.Symbol);
+```
+
+---
+
+## 13. Mnożenie procentu
+
+```csharp
+Percent p = (Percent)WartośćWskaźnikaObj("Pomniejszenie premii", okres.To);
+p = new Percent(((decimal)p) * Składnik.Dni);
+```
+
+---
+
+## 14. Podatki
+
+```csharp
+Decimal KosztyMnoznik = Element.Pracownik[Element.Data].Podatki.KosztyMnoznik;
+Decimal UlgaMnoznik = Element.Pracownik[Element.Data].Podatki.UlgaMnoznik;
+```
+
+---
+
+## 15. Przeliczenie Netto → Brutto
+
+```csharp
+Składnik.Podstawa1 = Element.DodHistoria.Podstawa;
+Składnik.Podstawa2 = NettoBrutto(Element, Składnik.Podstawa1);
+
+// lub z wartości decimal:
+decimal netto = (decimal)Składnik.Podstawa1.Value;
+decimal brutto = NettoBrutto(Element, netto).Value;
+```
+
+---
+
+## 16. Naliczanie urlopów i ekwiwalentów
+
+### Urlop wypoczynkowy i okolicznościowy
+
+```csharp
+new NaliczanieWypoczynkowy(Element, Składnik).NaliczPodstawy();
+// lub:
+new NaliczanieOkolicznosciowy(Element, Składnik).NaliczPodstawy();
+
+return (Currency)(Składnik.Podstawa1 * Składnik.Czas)
+     + (Currency)(Składnik.Podstawa2 * Składnik.Dni);
+```
+
+### Ekwiwalent z parametrami niestandardowymi
+
+```csharp
+NaliczanieEkwiwalent Naliczanie = new NaliczanieEkwiwalent(Element, Składnik);
+Naliczanie.ŚredniaNormaMiesięczna = 21.0;
+Naliczanie.OkresPodstawy = 3;
+Naliczanie.WgWymiaruEtatu = false;
+Naliczanie.NaliczPodstawy();
+
+return (Currency)(Składnik.Podstawa1 * Składnik.Czas)
+     + (Currency)(Składnik.Podstawa2 * Składnik.Dni);
+```
+
+---
+
+## 17. Porównywanie wartości
+
+```csharp
+Składnik.Podstawa1 = Currency.Max(Składnik.Podstawa1, Składnik.Podstawa2);
+Składnik.Podstawa1 = Currency.Min(Składnik.Podstawa1, Składnik.Podstawa2);
+```
+
+---
+
+## 18. Porównywanie fragmentu nazwy
+
+```csharp
+DoubleCy Podstawa = WartośćWskaźnika("Bony podarunkowe", Element.Okres.To);
+if (Element.PracHistoria.Etat.Stanowisko.Length >= 9
+    && Element.PracHistoria.Etat.Stanowisko.Substring(0, 9) == "Kierownik")
+    Podstawa = WartośćWskaźnika("Bony podarunkowe kier", Element.Okres.To);
+```
+
+---
+
+## 19. Suma czasu pracy w wydziale
+
+```csharp
+Wydzial Wydział = Element.PracHistoria.Etat.Wydzial;
+Time CzasPracaWydz = Time.Zero;
+
+foreach (Pracownik p in Kadry.Pracownicy) {
+    Periods ps = Periods.Empty;
+    foreach (PracHistoria ph in p.Historia.GetIntersectedRows(Składnik.Okres))
+        if (ph.Etat.Wydzial == Wydział)
+            ps += ph.Etat.EfektywnyOkres;
+    ps = ps.ToFlat() * Składnik.Okres;
+    CzasPracaWydz += p.Czasy.KalkPracy.Praca(ps).Czas;
+}
+Składnik.Czas = CzasPracaWydz;
+```
+
+---
+
+## 20. Stawka za km
+
+```csharp
+Soneta.Samochodowka.SamochodowkaModule sm
+    = Soneta.Samochodowka.SamochodowkaModule.GetInstance(Element);
+double v = sm.Config.StawkiZaKm.SamochodPonad900[Element.Okres.From];
+return new DoubleCy(v);
+```
+
+---
+
+## 21. Pomniejszenie akordowe
+
+```csharp
+Składnik.Podstawa1 = 0.0m;
+foreach (WypElement e in Element.Elementy[Element.Okres])
+    if (e.RodzajZrodla == RodzajŹródłaWypłaty.Etat)
+        foreach (WypSkladnik s in e.Skladniki)
+            if (s is WypSkladnikOdchyłka.AkordMinus)
+                Składnik.Podstawa1 -= s.Wartosc;
+```
+
+---
+
+## 22. Debugowanie i logowanie
+
+### Komunikaty Msg (widoczne w obliczeniach elementu)
+
+```csharp
+Msg("Premia za 1 sztukę: " + PdstPremii);
+Msg("Liczba sztuk: " + LiczbaSztuk);
+```
+
+### Zapis obliczeń (widoczny w formularzu elementu)
+
+```csharp
+Składnik.Podstawa1 = 150;
+Element.ZapisObliczen = "Podstawa: " + Składnik.Podstawa1;
+```
+
+### Logi systemowe
+
+```csharp
+Soneta.Business.Log log = new Soneta.Business.Log("Log do premii");
+log.WriteLine("Naliczanie premii uznaniowej dla: " + Pracownik);
+log.WriteLine(e.Nazwa + ": " + e.Wartosc);
+```
+
+---
+
+## 23. Sprawdzenie akordu
+
+```csharp
+var jestAkord = !Pracownik.Akordy.IsEmpty;
+```
+
+---
+
+## 24. Zaliczka wydział
+
+```csharp
+var wydzialZaliczka = Element.Zaliczka.Realizacja.Wydzial;
+var wydzialSplata = Element.Wydzial;
+
+if (wydzialSplata == wydzialZaliczka)
+    Składnik.Podstawa1 = SpłataZaliczkiNieopodatkowanej(Element, Składnik);
+```

soneta-place-def-elementow/references/wzorce-algorytmiczne.md

@@ -0,0 +1,176 @@
+# Wzorce algorytmiczne — wnioski z analizy ~247 rzeczywistych definicji
+
+Znajomość tych wzorców pozwala szybko tworzyć nowe definicje przez analogię. Każdy wzorzec opisuje źródło podstawy, formułę obliczeniową i przykładowe definicje.
+
+## Wzorce dla Dodatków (WypElementDodatek)
+
+### Wzorzec A — Kwota z historii (~10 definicji)
+
+- **Źródło podstawy:** `Element.DodHistoria.Podstawa`
+- **Formuła _Wylicz:** `Składnik.Podstawa1`
+- **Przykłady:** Dodatek funkcyjny, Premia, Składka PZU, Zasiłek rodzinny
+
+### Wzorzec B — Kwota z konfiguracji (~9 definicji)
+
+- **Źródło podstawy:** `module.Config.Zasiłki.*[Element.Okres.To]`
+- **Formuła _Wylicz:** `Składnik.Podstawa1`
+- **Przykłady:** Zas.pielęgnacyjny, Zas.pogrzebowy, Zas.porodowy
+
+### Wzorzec C — Kwota z definicji (~3 definicje)
+
+- **Źródło podstawy:** `Element.Definicja.Algorytm.KreatorAlgorytmu.Podstawa`
+- **Formuła _Wylicz:** `Składnik.Podstawa1`
+- **Przykłady:** Korekta składek ZUS, Korekta zaliczki podatku
+
+### Wzorzec D — ZasadniczeNominalne + Procent/Staż (~2 definicje)
+
+- **Źródło podstawy:** `ZasadniczeNominalne(Element.Okres.To)`
+- **Formuła _Wylicz:** `Podstawa1 * Procent`
+- **Przykłady:** Premia procentowa, Dodatek stażowy
+
+### Wzorzec E — NaliczanieEkwiwalent (~4 definicje)
+
+- **Źródło podstawy:** `NaliczanieEkwiwalent(Element, Składnik).NaliczPodstawy()`
+- **Formuła _Wylicz:** `Podstawa1 * Dni + Podstawa2 * Czas`
+- **Przykłady:** Ekwiwalent za urlop, Odprawa emerytalna, Odprawa, Odszkodowanie
+
+### Wzorzec F — OdsetkiZUS (~14 definicji)
+
+- **Źródło podstawy:** `OdsetkiZUS_ParamInt(Element, Składnik)`
+- **Formuła _Wylicz:** `Składnik.Podstawa1`
+- **Przykłady:** Odsetki wynagr.chorobowe, Odsetki zas.macierzyński
+
+### Wzorzec G — Ryczałt samochodowy (~10 definicji)
+
+- **Źródło podstawy:** Stawka z `SamochodowkaModule.Config.StawkiZaKm.*`
+- **Formuła _Wylicz:** `Podstawa1 * Współczynnik * (1 - Dni/22)`
+- **Przykłady:** Ryczałt za paliwo, Ryczałt użyt.sam.służb.
+
+### Wzorzec H — Praca zdalna (~3 definicje)
+
+- **Źródło podstawy:** `Element.Module.Config.PracaZdalna.Stawka*`
+- **Formuła _Wylicz:** `Podstawa1 * Czas` lub `Podstawa1 * Dni`
+- **Przykłady:** Ekwiwalent/ryczałt za pracę zdalną
+
+### Wzorzec I — Dodatki rodzinne (~5 definicji)
+
+- **Źródło podstawy:** `module.Config.Zasiłki.DodRodzinny*` (zależne od wieku/miesiąca)
+- **Formuła _Wylicz:** `Składnik.Podstawa1`
+- **Przykłady:** Dod. kształcenie, nauka, rok szkolny, urodzenie dziecka
+
+### Wzorzec J — Wyrównanie macierzyńskiego (1 definicja)
+
+- **Źródło podstawy:** `PodwyższenieMacierzyńskiego(Element, Składnik).NaliczPodstawy()`
+- **Formuła _Wylicz:** `Max(podstawa - zasiłekNetto, 0)`
+- **Przykłady:** Wyrównanie zas. macierzyńskiego
+
+### Wzorzec K — Świadczenie z limitem (1 definicja)
+
+- **Źródło podstawy:** `Element.DodHistoria.Podstawa` + kontrola limitu rocznego
+- **Formuła _Wylicz:** Z uwzględnieniem limitu podatkowego
+- **Przykłady:** Świadczenie socjalne (z limitem, dodatek)
+
+### Wzorzec L — EdytorAlgorytmu custom (1 definicja)
+
+- **Źródło podstawy:** `ZasadniczeNominalne(Element.Okres.To)`
+- **Formuła _Wylicz:** `Podstawa1 - (Podstawa1 * Dni / 28)`
+- **Przykłady:** Potrącenie za nieobecność 1/28
+
+---
+
+## Wzorce dla Nieobecności (WypElementNieobecnosc)
+
+### Wzorzec A — PodstawaZasiłku (~51 definicji)
+
+- **Klasa pomocnicza:** `new PodstawaZasiłku(Element)`
+- **Formuła _Wylicz:** `WyliczPodstawęZasiłkuZaDzień(...) * Dni`
+- **Przykłady:** Zas.chorobowy, Zas.macierzyński, Zas.opiekuńczy, Wynagr.chorobowe, Świad.rehabilitacyjne
+
+### Wzorzec B — NaliczanieOkolicznosciowy (~15 definicji)
+
+- **Klasa pomocnicza:** `new NaliczanieOkolicznosciowy(Element, Składnik).NaliczPodstawy()`
+- **Formuła _Wylicz:** `Podstawa1 * Czas + Podstawa2 * Dni`
+- **Przykłady:** Wynagr.urlop okolicznościowy, Wynagr.delegacja, Wynagr.badania lekarskie, Wynagr.urlop na poszukiwanie pracy
+
+### Wzorzec C — JakUrlopWypoczynkowy (1 definicja)
+
+- **Klasa pomocnicza:** Wbudowany algorytm
+- **Formuła _Wylicz:** Wbudowany
+- **Przykłady:** Wynagr.urlop wypoczynkowy
+
+### Wzorzec D — Kreator z Kwotą (1 definicja)
+
+- **Klasa pomocnicza:** `Element.Definicja.Algorytm.KreatorAlgorytmu.Podstawa`
+- **Formuła _Wylicz:** `Składnik.Podstawa1.Ceiling(1)`
+- **Przykłady:** Urlop wychowawczy
+
+### Wzorzec E — WartośćZasiłku (~3 definicje)
+
+- **Klasa pomocnicza:** `WartośćZasiłku(Element, Składnik, kwota)`
+- **Formuła _Wylicz:** `Składnik.Podstawa1.Ceiling(1)`
+- **Przykłady:** Zas.wychowawczy (1,2 dziecko / 3... dziecko / osoba samotna)
+
+---
+
+## Wzorce dla Dodatków automatycznych (WypElementDodatekAutomatyczny)
+
+### Wzorzec A — Składki budżetowe (1 definicja)
+
+- **Opis:** `PodstawaSkładekZUSWłaścicielaWakacjeSkładkowe(Element)`
+- **Przykłady:** Dochód deklarowany - składki budżetowe
+
+### Wzorzec B — Dofinansowanie (1 definicja)
+
+- **Opis:** Kwota z `Pracownik.BadaniaLekarskie` (LINQ)
+- **Przykłady:** Dofinansowanie okulary lub soczewki
+
+### Wzorzec C — Potrącenie OPP (1 definicja)
+
+- **Opis:** `PodstawyPotrąceniaOPP(Element, Składnik)` + metody Odbiorca/Rachunek
+- **Przykłady:** Potrącenie OPP
+
+### Wzorzec D — Przychód PPK (~4 definicje)
+
+- **Opis:** `TymczasowoNaliczPodatki` + iteracja elementów wypłaty
+- **Przykłady:** Przychód od skł. pracod. PPK (etat/umowa/um.poz/RSP)
+
+### Wzorzec E — Wynagrodzenie postojowe (2 definicje)
+
+- **Opis:** Stawka 1h vs najniższe wynagrodzenie, czas ze strefy przestoju
+- **Przykłady:** Wynagrodzenie postojowe (ekonomiczne/KP)
+
+---
+
+## Statystyki definicji w systemie
+
+| Rodzaj | Aktywne + Zablokowane |
+|---|---|
+| Dodatek | 51 |
+| Nieobecność | 70 |
+| Umowa | 43 |
+| Pożyczka spłata | 10 |
+| Przychód PPK | 9 |
+| Dodatek automatyczny | 9 |
+| Fund poż wycofanie | 6 |
+| Fund poż wpisowe | 5 |
+| Zbieg pracy i rodzicielstwa | 5 |
+| Zajęcie komornicze | 4 |
+| Zwrot nadpłaty PPK | 4 |
+| Etat | 3 |
+| Wyrównanie do minimalnej | 3 |
+| Umowa rozliczenie | 3 |
+| Nocne | 2 |
+| Świadczenie | 2 |
+| Odchyłki | 2 |
+| Zaliczka | 2 |
+| Zaliczka zwrot | 2 |
+| Pożyczka | 2 |
+| Fund poż składka | 2 |
+| Nadgodziny I/II/św | 1+1+1 |
+| Akord | 1 |
+| Nagroda | 1 |
+| Kara | 1 |
+| Kurs | 1 |
+| Zajęcie komornicze rozlicz depozytu | 1 |
+| Zajęcie komornicze zwrot nadpłaty | 1 |
+| **Łącznie** | **~247** |