dostapczuk/soneta-erp-skills

Fork 0

Files

T

Marcin Wojas 29f5aca0a2 soneta-place-def-elementow

2026-03-26 23:19:11 +01:00

10 KiB

Raw Blame History

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:

// 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):

// 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

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

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)

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

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%

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.

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);
}

10 KiB Raw Blame History Unescape Escape