/// <summary>
        /// Procedura sterge situatia lunara a unui angajat
        /// </summary>
        /// <param name="isl">Obiectul care contine situatia lunara</param>
        /// <returns>Returneaza rezultatul stergerii</returns>
        public int DeleteSituatieLunaraAngajat(Salaries.Data.InfoSituatieLunara isl)
        {
            //Adaugat:		Oprescu Claudia
            //Descriere:	Daca se sterge situatia lunara a unui angajat, valorile pentru retineri sunt setate pe 0 pentru angajatul respectiv
            TipuriRetineriValori trv = new TipuriRetineriValori();

            trv.UpdateRetineriValori(isl.LunaID, isl.AngajatID, 0, 0, 0, 0, 0, 0, 0);

            return(new Salaries.Data.SituatieLunaraAngajat(this.settings.ConnectionString).DeleteSituatieLunaraAngajat(isl));
        }
        /// <summary>
        /// Procedura adauga situatia lunara a unui angajat
        /// </summary>
        /// <param name="isl">Obiectul care contine situatia lunara</param>
        /// <param name="ValidareStergere">Se face validare la stergere sau nu</param>
        /// <returns>Returneaza rezultatul rfectuarii adaugarii</returns>
        public int AddSituatieLunaraAngajat(Salaries.Data.InfoSituatieLunara isl, bool ValidareStergere)
        {
//			try
//			{
            return(this.AddSituatieLunaraAngajat(isl.LunaID, isl.AngajatID, isl.NrZileLuna, isl.NrOreLucrate, isl.NrOreSup50Proc, isl.NrOreSup100Proc, isl.NrOreEvenimDeoseb, isl.NrOreInvoire, isl.NrOreConcediuOdihna, isl.NrZileConcediuOdihnaNeefectuat, isl.NrZileConcediuOdihnaEfectuatInAvans, isl.NrOreConcediuBoala, isl.NrOreConcediuBoalaFirma, isl.NrOreConcediuBoalaBASS, isl.NrOreObligatiiCetatenesti, isl.NrOreAbsenteNemotivate, isl.NrOreConcediuFaraPlata, isl.NrOreTotalDelegatieInterna, isl.NrOreTotalDelegatieExterna, isl.NrOreLucrateDelegatieInterna, isl.NrOreLucrateDelegatieExterna, isl.DiurnaImpozabila, isl.NrOreEmergencyService, isl.NrTichete, isl.CorectiiTichete, isl.NrTotalTichete, isl.SporActivitatiSup, isl.EmergencyService, isl.PrimeSpeciale, isl.AlteDrepturi, isl.AlteDrepturiNet, isl.AjutorDeces, isl.Avans, /*isl.Retineri,*/ isl.Regularizare, isl.PrimaProiect, isl.RetinereSanatate, isl.DrepturiInNatura, isl.ProgramLucru, isl.SalariuBaza, isl.IndemnizatieConducere, isl.Invaliditate, isl.CategorieID, ValidareStergere));
//			}
//			catch( Exception exc)
//			{
//				string aaa = exc.Message;
//				return -1;
//			}
        }
        private void Page_Load(object sender, System.EventArgs e)
        {
            //Modificat: Cristina Muntean ... se permite modificarea pontajului numai daca luna selectata de
            //utilizator este luna activa a angajatorului sau daca exista situatie lunara pentru angajatul selectat

            //luna selectata de utilizator
            int lunaCurentaID = int.Parse(this.Session[SiemensHR.InterfataSalarii.Classes.Definitions.LunaCurentaKey].ToString());
            //id-ul angajatului selectat in dropdownlist
            int angajatID = this.GetAngajat();

            Salaries.Business.Angajat objAngajat = new Salaries.Business.Angajat();
            objAngajat.AngajatId = angajatID;
            objAngajat.LoadAngajat();

            //luna activa a angajatorului
            Salaries.Business.Luni luna     = new Salaries.Business.Luni(objAngajat.AngajatorId);
            Salaries.Data.LunaData lunaData = luna.GetLunaActiva();

            //se obtine situatie lunara a angajatului
            Salaries.Business.SituatieLunaraAngajat situatieLunaraAng  = new Salaries.Business.SituatieLunaraAngajat(objAngajat.AngajatId);
            Salaries.Data.InfoSituatieLunara        infoSituatieLunara = situatieLunaraAng.GetSituatieLunaraAngajat(objAngajat.AngajatId, lunaData.LunaId);

            //daca luna selectata de utilizator nu este luna activa sau daca nu exista o situatie lunara pentru angajatul selectat
            //atunci se permite doar vizualizarea pontajului,altfel se permite si modificarea acestuia
            if ((lunaCurentaID != lunaData.LunaId) || (infoSituatieLunara.SituatieID == -1))
            {
                //HtmlTableCell IntervaleContainer este ascunsa
                IntervaleContainer.Style.Add("display", "none");
            }
            else
            {
                //HtmlTableCell IntervaleContainer este facuta vizibila
                IntervaleContainer.Style.Add("display", "");
            }

            ClientSelectedDate1 = (System.Web.UI.HtmlControls.HtmlInputHidden)Page.FindControl("ClientSelectedDate");
            this.DoQuickLogin(this.GetAngajat());
        }
Example #4
0
        private void btnGenerati_Click(object sender, System.EventArgs e)
        {
            // Date luna anterioara.
            Salaries.Data.LunaData lunaAnterioara = luni.GetDetaliiByData(lunaData.Data.AddMonths(-1));
            // Situatia lunara a angajatului.
            Salaries.Business.SituatieLunaraAngajat situatieLunara = new Salaries.Business.SituatieLunaraAngajat(objAngajat.AngajatId);
            // Situatia lunara din luna curenta.
            Salaries.Data.InfoSituatieLunara infoSituatieLunara = situatieLunara.GetSituatieLunaraAngajat(objAngajat.AngajatId, lunaData.LunaId);
            // Situatia lunara de pe luna precedenta.
            Salaries.Data.InfoSituatieLunara infoSituatieLunaraAnt = situatieLunara.GetSituatieLunaraAngajat(objAngajat.AngajatId, lunaAnterioara.LunaId);

            Salaries.Business.Salariu salariu = new Salaries.Business.Salariu();
            salariu.AngajatID = objAngajat.AngajatId;

            // true, daca este luna incheie un trimestru, false altfel
            bool lnSfDeTrim = false;
            // Suma cu care a fost majorat salariul angajatului.
            float sumaMajorare = 0;

            // Valoarea indexata a venitului brut.
            float venitBrutIndexat = 0;

            int lunaCurenta = int.Parse(luni.GetLunaActiva().Data.Month.ToString());

            switch (lunaCurenta)
            {
            case LUNA_INDEXARE_1:
                lnSfDeTrim = true;
                break;

            case LUNA_INDEXARE_2:
                lnSfDeTrim = true;
                break;
            }

            venitBrutIndexat = salariu.CalculVenitBrutIndexat();

            /*
             *      Se verifica daca este cazul sa se genereze o astfel de comunicare.
             * Anul este impartit in patru trimestre(lunile 1-3,4-6,7-9,10-12)
             * Indexarea se reflecta in salariul din ultima luna a trimestrului. Cum
             * salariul primit in luna activa este de pe luna anterioara, indexarea
             * trebuie sa fie facuta in fiecare din lunile 1,4,7 si 10.Se verifica, de asemenea,
             * daca angajatul a lucrat cel putin o luna pe trimestrul anterior.
             */
            if ((lnSfDeTrim) && (venitBrutIndexat != 0))
            {
                // Sunt introduse in sesiune datele referitoare la comunicare.
                // Tipul comunicarii.
                Session["TipComunicare"] = "comunicare indexare.xml";
                // Numarul comunicarii.
                Session["Numar"] = txtNrCom.Text;
                // Data inregistrarii comunicarii.
                Session["DataInregistrarii"] = txtDataInregistrarii.Text;
                // Procentul inflatiei.
                Session["ProcentIndexare"] = (salariu.CalculProcentIndexareAngajat() - 1) * 100;
                // Este calculata valoarea majorarii.
                sumaMajorare = (infoSituatieLunara.IndemnizatieConducere - infoSituatieLunaraAnt.IndemnizatieConducere) +
                               (infoSituatieLunara.SalariuBaza - salariu.CalculVenitBrutIndexat());
                // Valoare majorare.
                Session["SumaMajorare"] = sumaMajorare;
                // Numele managerului general.
                Session["ManagerGeneral"] = txtManagerGeneral.Text;
                // Numele directorului economic.
                Session["DirectorEconomic"] = txtDirectorEconomic.Text;

                Response.Redirect("Comunicari/comunicare.aspx?id=" + objAngajat.AngajatId);

                lblEroare.Text = "Comunicarea a fost generata.";
            }
            // Altfel este afisat un mesaj de eroare.
            else
            {
                if (!lnSfDeTrim)
                {
                    lblEroare.Text = "Pe aceasta luna nu trebuie generata o astfel de comunicare!";
                }
                if (venitBrutIndexat == 0)
                {
                    lblEroare.Text = "Acestui angajat nu trebuie sa ii fie indexat salariul!";
                }
            }
        }
        /// <summary>
        /// Initializeaza luna
        /// </summary>
        private void InitializareLunaClick()
        {
            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - start - click_initializareLuna()");
            // Va contine salariile indexate ale angajatilor.
            DataSet dsSalariiIndexate = new DataSet();

            Salaries.Business.Luni luna = new Salaries.Business.Luni(this.GetAngajator());
            ArrayList categs            = new ArrayList();

            /*
             * Adaugat:		Oprescu Claudia
             * Data:		24.04.2007
             * Descriere:	Daca exista angajati carora le-a expirat contractul de munca, nu se permite initializarea lunii pentru care trebuie facuta indexarea
             */
            if (performIndexing && ((this.SelectedDate.Month == 4) || (this.SelectedDate.Month == 10)))
            {
                Salaries.Business.Angajat angajati = new Salaries.Business.Angajat();
                Salaries.Business.IstoricSchimbareDateAngajat dataPosibilaIndexare = new Salaries.Business.IstoricSchimbareDateAngajat();
                dataPosibilaIndexare.DataStart = luna.GetLunaActiva().Data;
                while (dataPosibilaIndexare.DataEsteZiSarbatoare())
                {
                    dataPosibilaIndexare.DataStart = dataPosibilaIndexare.DataStart.AddDays(1);
                }
                DataSet dsAngajatiExpiraContract = angajati.GetAngajatiExpiraContractLunaCurenta(dataPosibilaIndexare.DataStart);
                if (dsAngajatiExpiraContract.Tables[0].Rows.Count != 0)
                {
                    Response.Write("<script> alert('Exista angajati carora le-a expirat contractul de munca, adica data de sfarsit a contractului este mai mica decat prima zi lucratoare a lunii curente. \\nPentru a vizualiza acesti angajati, accesati modulul Home al aplicatiei. \\nVa rugam actualizati data de sfarsit a contractului pentru acesti angajati pentru a se putea efectua indexarea. \\nVa multumim!'); </script>");
                    return;
                }
            }

            InitializeOreLucrateLunaAngajati();

            if (this.lstCategorii.SelectedIndex == 0)
            {
                for (int i = 1; i < this.lstCategorii.Items.Count; i++)
                {
                    categs.Add(int.Parse(this.lstCategorii.Items[i].Value));
                }
            }
            else
            {
                categs.Add(this.lstCategorii.SelectedValue);
            }

            /*
             * Adaugat:  Muntean Raluca Cristina
             * Data:     29.12.2005
             * Descriere:Sunt calculate salariile indexate ale angajatilor
             * si introduce schimbarea in baza de date.
             *
             * Modificat:
             *		- Ionel Popa - 18.12.2006: indexarea se face o data la sase luni: aprilie si octombrie
             */
            if (performIndexing && ((this.SelectedDate.Month == 4) || (this.SelectedDate.Month == 10)))
            {
                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - start - indexare");
                //a fost exectuata indexare si campul pentru specificarea indexarii este inactiv
                tdIndexare.Disabled      = true;
                indexareCheckBox.Checked = true;

                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - start - calcul salarii indexate");
                dsSalariiIndexate = luna.CalculSalariiIndexate(this.GetAngajator());
                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - end - calcul salarii indexate");

                Salaries.Business.Angajat ang = new Salaries.Business.Angajat();
                Salaries.Business.IstoricSchimbareDateAngajat isda;
                Salaries.Data.LunaData lunaActiva = luna.GetLunaActiva();
                string dataLunaActiva             = lunaActiva.Data.ToShortDateString();

                //Se creaza noul interval de schimbari:
                //Va contine ca data de start inceputul lunii si ca data de sfarsit DataTime.MaxValue
                Salaries.Business.IstoricSchimbareDateAngajat intsch = new Salaries.Business.IstoricSchimbareDateAngajat();
                intsch.DataEnd   = DateTime.MaxValue;
                intsch.DataStart = DateTime.Parse(dataLunaActiva);
                //se stabileste data de inceput a schimbarii
                //daca este o zi de sarbatoare, se va lua data urmatoare
                while (intsch.DataEsteZiSarbatoare())
                {
                    intsch.DataStart = intsch.DataStart.AddDays(1);
                }

                Salaries.Business.IstoricSchimbareDateAngajat interv;
                //Un angajat poate avea cel putin un interval care se termina inaintea datei de inceput a intervalului de schimbare
                //In acest caz retinem acest interval
                //Salaries.Business.IstoricSchimbareDateAngajat possibleLastInterval;

                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - start - schimbare date angajat(sal indexat)");
                foreach (DataRow angajatRow in dsSalariiIndexate.Tables[0].Rows)
                {
                    ang.AngajatId = long.Parse(angajatRow["AngajatID"].ToString());
                    ang.LoadAngajat();

                    //Se initializeaza schimbarile angajatului
                    isda             = new Salaries.Business.IstoricSchimbareDateAngajat();
                    isda.AngajatId   = ang.AngajatId;
                    isda.DataStart   = intsch.DataStart;
                    intsch.AngajatId = ang.AngajatId;

                    if (!ang.IsLichidat)
                    {
                        interv = new Salaries.Business.IstoricSchimbareDateAngajat();
                        DataSet existaCapat = new DataSet();

                        //Se verifica daca data de angajare este diferita de inceputul intervalului de schimbare
                        //In cazul in care sunt egale ... nu se face indexarea

                        /*if(ang.DataDeLa != intsch.DataStart)
                         * {
                         *      //Se extrage intervalul precedent intervalului de schimbare
                         *      isda.DataStart = intsch.DataStart.AddDays( -1 );
                         *      interv = isda.GetIntervalSchimbareByDataInside();
                         *      //In cazul in care angajatul a fost angajat pe o perioada determinata e posibil sa nu existe un interval care sa includa aceasta data
                         *      if( interv.ProgramLucru == -1)
                         *      {
                         *              interv = isda.GetLastIntervalSchimbare();
                         *              //Se seteaza doar DataEnd pentru ca aceasta e necesara mai jos in InsertCapatIntervalSchimbareAngajat/UpdateCapatIntervalSchimbareAngajat
                         *              interv.DataStart = intsch.DataStart.AddDays( -1 );
                         *              //Initializam si acest interval
                         *              possibleLastInterval = isda.GetLastIntervalSchimbare();
                         *              possibleLastInterval.DataStart = intsch.DataStart.AddDays( -1 );
                         *              isda.CategorieId = interv.CategorieId;
                         *              possibleLastInterval.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();
                         *      }
                         *      else
                         *      {
                         *              isda.CategorieId = interv.CategorieId;
                         *              interv.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();
                         *              //Initializam si acest interval
                         *              isda.DataStart = intsch.DataStart.AddDays( -1 );
                         *              possibleLastInterval = isda.GetIntervalSchimbareByDataInside();
                         *              isda.CategorieId = interv.CategorieId;
                         *              possibleLastInterval.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();
                         *      }
                         *
                         *
                         *      //Se verifica daca data de start a intervalului de schimbare este capat de interval
                         *      //Aceasta verificare este necesara pentru ca intervalele sa fie continue
                         *      //De ex: in cazul in care exista un capat mai mic decat capatul de start al intervalului de schimbare acesta este actualizat cu capatul de start al intervalului de schimbare
                         *      //!!Prin actiunea de mai jos se seteaza ca si capat de interval ultima zi a lunii precedente
                         *      isda.DataStart = intsch.DataStart.AddDays( -1 );
                         *      existaCapat = isda.GetCapatIntervalAngajatZi();
                         *      if ( existaCapat == null || existaCapat.Tables[ 0 ].Rows.Count == 0 )
                         *      {
                         *              //Daca nu exista un capat de interval acesta va fi inserat
                         *              interv.InsertCapatIntervalSchimbareAngajat();
                         *      }
                         *      else
                         *      {
                         *              //Daca exista un capat de interval acesta este actualizat
                         *              interv.IntervalAngajatId = int.Parse( existaCapat.Tables[ 0 ].Rows[ 0 ][ "IntervalAngajatID" ].ToString());
                         *              interv.UpdateCapatIntervalSchimbareAngajat();
                         *      }
                         *
                         *      //Se actulizeaza salariul de baza cu cel indexat
                         *      intsch.SalariuBaza = decimal.Parse( angajatRow["SalariuIndexat"].ToString() );
                         *      //Se insereaza schimbarea pentru angajatul curent
                         *      intsch.InsertSchimbareSalariuBaza();
                         *
                         *      //Se seteaza ca si capat de interval inceputul lunii active
                         *      isda.DataStart = intsch.DataStart;
                         *      interv = isda.GetIntervalSchimbareByDataInside();
                         *      if( interv.ProgramLucru == -1)
                         *      {
                         *              interv = possibleLastInterval;
                         *              interv.DataStart = DateTime.Parse(dataLunaActiva );
                         *      }
                         *      interv.SalariuBaza = intsch.SalariuBaza;
                         *      isda.CategorieId = interv.CategorieId;
                         *      interv.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();
                         *
                         *      isda.DataStart = intsch.DataStart;
                         *      existaCapat = isda.GetCapatIntervalAngajatZi();
                         *      if( existaCapat == null || existaCapat.Tables[ 0 ].Rows.Count == 0 )
                         *      {
                         *              interv.InsertCapatIntervalSchimbareAngajat();
                         *      }
                         *      else
                         *      {
                         *              interv.IntervalAngajatId = int.Parse( existaCapat.Tables[ 0 ].Rows[ 0 ][ "IntervalAngajatID" ].ToString());
                         *              interv.UpdateCapatIntervalSchimbareAngajat();
                         *      }
                         * }*/

                        //Se verifica daca data de angajare este diferita de inceputul intervalului de schimbare
                        //In cazul in care sunt egale ... nu se face indexarea
                        if (ang.DataDeLa != intsch.DataStart)
                        {
                            //Se extrage intervalul precedent intervalului de schimbare
                            isda.DataStart = intsch.DataStart.AddDays(-1);
                            //daca este o zi de sarbatoare, se va trece la ziua anterioara pana se va gasi o zi care nu este sarbatoare
                            while (isda.DataEsteZiSarbatoare())
                            {
                                isda.DataStart = isda.DataStart.AddDays(-1);
                            }
                            interv             = isda.GetIntervalSchimbareByDataInside();
                            isda.CategorieId   = interv.CategorieId;
                            interv.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();

                            //Se verifica daca data de start a intervalului de schimbare este capat de interval
                            //Aceasta verificare este necesara pentru ca intervalele sa fie continue
                            //De ex: in cazul in care exista un capat mai mic decat capatul de start al intervalului de schimbare acesta este actualizat cu capatul de start al intervalului de schimbare
                            //!!Prin actiunea de mai jos se seteaza ca si capat de interval ultima zi a lunii precedente
                            isda.DataStart = intsch.DataStart.AddDays(-1);
                            //daca este o zi de sarbatoare, se va trece la ziua anterioara pana se va gasi o zi care nu este sarbatoare
                            while (isda.DataEsteZiSarbatoare())
                            {
                                isda.DataStart = isda.DataStart.AddDays(-1);
                            }
                            existaCapat = isda.GetCapatIntervalAngajatZi( );
                            if (existaCapat == null || existaCapat.Tables[0].Rows.Count == 0)
                            {
                                //Daca nu exista un capat de interval acesta va fi inserat
                                interv.InsertCapatIntervalSchimbareAngajat();
                            }
                            else
                            {
                                //Daca exista un capat de interval acesta este actualizat
                                interv.IntervalAngajatId = int.Parse(existaCapat.Tables[0].Rows[0]["IntervalAngajatID"].ToString());
                                interv.UpdateCapatIntervalSchimbareAngajat();
                            }
                        }

                        //Se actulizeaza salariul de baza cu cel indexat
                        intsch.SalariuBaza = decimal.Parse(angajatRow["SalariuIndexat"].ToString());
                        //Se insereaza schimbarea pentru angajatul curent
                        intsch.InsertSchimbareSalariuBaza();

                        //Se seteaza ca si capat de interval inceputul lunii active
                        isda.DataStart     = intsch.DataStart;
                        interv             = isda.GetIntervalSchimbareByDataInside();
                        interv.SalariuBaza = intsch.SalariuBaza;
                        isda.CategorieId   = interv.CategorieId;
                        interv.CategorieId = isda.GetCategorieCorspunzatoareDinLunaActiva();

                        isda.DataStart = intsch.DataStart;
                        existaCapat    = isda.GetCapatIntervalAngajatZi();
                        if (existaCapat == null || existaCapat.Tables[0].Rows.Count == 0)
                        {
                            interv.InsertCapatIntervalSchimbareAngajat();
                        }
                        else
                        {
                            interv.IntervalAngajatId = int.Parse(existaCapat.Tables[0].Rows[0]["IntervalAngajatID"].ToString());
                            interv.UpdateCapatIntervalSchimbareAngajat();
                        }
                    }
                }
                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - end - schimbare date angajat(sal indexat)");
                ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - end - indexare");
            }

            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - start - adaugarea etichetelor asociate retinerilor");
            //Adaugat:		Oprescu Claudia
            //Descriere:	La initializarea fiecarei luni se adauga etichetele asociate acesteia
            Salaries.Business.TypesOfRestraints tr = new Salaries.Business.TypesOfRestraints();
            tr.InsertLabel(this.GetCurrentMonth());

            //Descriere:	Pentru fiecare angajat se adauga valori pentru retinerea din luna nou adaugata
            Salaries.Business.Angajat angajat = new Salaries.Business.Angajat();
            DataSet angajatiID = angajat.GetAngajatIDAll();

            foreach (DataRow dr in angajatiID.Tables[0].Rows)
            {
                long AngajatID = long.Parse(dr["AngajatID"].ToString());
                Salaries.Business.TipuriRetineriValori trv = new Salaries.Business.TipuriRetineriValori();
                trv.InsertRetineriValori(this.GetCurrentMonth(), AngajatID);
            }
            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - end - adaugarea etichetelor asociate retinerilor");

            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - start - generare situatii lunare");
            for (int i = 0; i < categs.Count; i++)
            {
                int CategorieID = int.Parse(categs[i].ToString());

                DataSet CategorieAngajati = new Salaries.Business.CategoriiAngajat().GetCategorieAngajati(CategorieID);

                foreach (DataRow dr in CategorieAngajati.Tables[0].Rows)
                {
                    long AngajatID = long.Parse(dr["AngajatID"].ToString());

                    Salaries.Business.SituatieLunaraAngajat sla = new Salaries.Business.SituatieLunaraAngajat(AngajatID);
                    sla.GenerareSituatieLunaraAngajat(this.GetCurrentMonth(), this.GetAngajator());

                    //se adauga valorile retinerilor pentru un angajat dintr-o luna
                    //Salaries.Business.TipuriRetineriValori().InsertRetineriValori(this.GetCurrentMonth(), this.GetAngajator());

                    Salaries.Data.InfoSituatieLunara isl = sla.GetSituatieLunaraAngajat(AngajatID, this.GetCurrentMonth());

                    //Salaries.Business.SituatieLunaraAngajat sla = new Salaries.Business.SituatieLunaraAngajat(AngajatID);

                    Salaries.Data.InfoSituatieLunara x = new Salaries.Data.InfoSituatieLunara();

                    x.SituatieID                = -1;
                    x.AngajatID                 = AngajatID;
                    x.LunaID                    = this.GetCurrentMonth();
                    x.NrZileLuna                = isl.NrZileLuna;
                    x.NrOreConcediuBoala        = isl.NrOreConcediuBoala;
                    x.NrOreConcediuOdihna       = isl.NrOreConcediuOdihna;
                    x.NrOreEvenimDeoseb         = isl.NrOreEvenimDeoseb;
                    x.NrOreInvoire              = isl.NrOreInvoire;
                    x.NrOreObligatiiCetatenesti = isl.NrOreObligatiiCetatenesti;
                    x.NrOreAbsenteNemotivate    = isl.NrOreAbsenteNemotivate;
                    x.NrOreConcediuFaraPlata    = isl.NrOreConcediuFaraPlata;
                    x.NrOreLucrate              = isl.NrOreLucrate;
                    //x.NrOreSup100Proc = isl.NrOreSup100Proc;
                    //x.NrOreSup50Proc = isl.NrOreSup50Proc;
                    x.NrOreSup100Proc = int.Parse(this.txtNrOreSup100Proc.Text);
                    x.NrOreSup50Proc  = int.Parse(this.txtNrOreSup50Proc.Text);

                    x.PrimeSpeciale     = decimal.Parse(this.txtPrimeSpeciale.Text);
                    x.SporActivitatiSup = decimal.Parse(this.txtSporActivitatiSup.Text);
                    x.EmergencyService  = decimal.Parse(this.txtEmergencyService.Text);
                    x.AlteDrepturi      = decimal.Parse(this.txtAlteDrepturi.Text);
                    x.AlteDrepturiNet   = decimal.Parse(this.txtAlteDrepturiNet.Text);
                    x.Avans             = decimal.Parse(this.txtAvans.Text);
                    x.PrimaProiect      = decimal.Parse(this.txtPrimaProiect.Text);

                    //se calculeaza suma pe care trebuie sa o plateasca cei scutiti de contributia la sanatate
                    int lunaID = this.GetCurrentMonth();
                    x.RetinereSanatate = 0;
                    x.CategorieID      = CategorieID;

                    sla.AddSituatieLunaraAngajat(x, true);

                    //distribuie orele suplimentare
                    //ore 100%
                    lunaID = this.GetCurrentMonth();
                    Salaries.Business.Luni l  = new Salaries.Business.Luni(this.GetAngajator());
                    Salaries.Data.LunaData ld = l.GetDetalii(lunaID);
                    int tipIntervalID         = new SiemensTM.Classes.IntervaleAngajat(AngajatID).GetTipIntervalIDByName(Salaries.Business.SituatieLunaraAngajat.denumireOreLucrate[1]);;
                    int valEroare             = new SiemensTM.Classes.IntervaleAngajat(AngajatID).DistribuieOreSuplimentareTip(ld.Data, tipIntervalID, x.NrOreSup50Proc, 0, 0);

                    /*if ( valEroare == 1 )
                     * {
                     *      Response.Write( "<script>alert( 'Numarul de ore suplimentare 100% depaseste numarul de ore disponibile!' );</script>" );
                     * }*/

                    //ore 200%
                    tipIntervalID = new SiemensTM.Classes.IntervaleAngajat(AngajatID).GetTipIntervalIDByName(Salaries.Business.SituatieLunaraAngajat.denumireOreLucrate[2]);;
                    valEroare     = new SiemensTM.Classes.IntervaleAngajat(AngajatID).DistribuieOreSuplimentareTip(ld.Data, tipIntervalID, x.NrOreSup100Proc, 0, 1);

                    //Reportare
                    sla.ReporteazaDiferentaCorectiTichete(lunaID);
                    sla.GenerareSituatieLunaraAngajat(this.GetCurrentMonth(), this.GetAngajator());

                    /*if ( valEroare == 1 )
                     * {
                     *      Response.Write( "<script>alert( 'Numarul de ore suplimentare 200% depaseste numarul de ore disponibile!' );</script>" );
                     * }*/
                }
            }
            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - click_initializareLuna() - end - generare situatii lunare");
            ErrHandler.MyErrHandler.WriteError("InitializareLuna.ascx - end - click_initializareLuna()");
        }
 /// <summary>
 /// Procedura modifica situatia lunara a unui angajat
 /// </summary>
 /// <param name="isl">Obiect care contine noile date</param>
 /// <returns>Returneaza rezultatul modificarii</returns>
 public int ModifSituatieLunaraAngajat(Salaries.Data.InfoSituatieLunara isl)
 {
     return(new Salaries.Data.SituatieLunaraAngajat(this.settings.ConnectionString).UpdateSituatieLunaraAngajat(isl));
 }
        /// <summary>
        /// Procedura genereaza situatia lunara a unui angajat
        /// </summary>
        /// <param name="lunaID">Id-ul lunii pentru care se genereaza</param>
        /// <param name="angajatorID">Id-ul angajatorului</param>
        public void GenerareSituatieLunaraAngajat(int lunaID, int angajatorID)
        {
            //try
            //{
            Angajat angajat = new Angajat();

            angajat.AngajatId = AngajatID;
            angajat.LoadAngajat();

            PontajAngajat pa = new PontajAngajat(this.AngajatID, settings);

            Salaries.Data.InfoSituatieLunara isl = this.GetSituatieLunaraAngajat(this.AngajatID, lunaID);

            int nrZileLucratoareLunaTotal = pa.GetNrZileLuna(lunaID);

            TimeSpan nrOreTotaleLucrateLuna = pa.GetAngajatNrOreLucrateLuna(lunaID);

            int nrZileTotaleAbsentateLuna = pa.GetAngajatNrZileAbsenteTotalLuna(lunaID);

            Data.IntervaleSchimbariLuna [] intervSL = pa.GetIntervaleSchimbariLuna(lunaID);

            bool validareStergere = true;

            /*
             * Modified:    Cristina Raluca Muntean
             * Date:        1.09.2005
             * Description: Initial salariul si indemnizatia de conducere nu se puteau schimba decat pe data de 1 a lunii.
             * S-a revenit asupra acestei decizii si se doreste sa existe posibilitatea modificarii salariului de baza si
             * a indemnizatiei de conducere in orice zi a lunii. Va exista in continuare tot o singura situatie lunara, iar
             * salariul de baza si indemnizatia de conducere se vor calcula conform formulelei:
             * sumaRezultatat = suma perioada I/nr zile lucratoare*nr zile lucrate in perioada + suma perioada II/nr zile lucratoare*nr zile lucrate in perioada +...
             *
             */
            int [] nrZileLucratoareLuna          = new int[intervSL.Length];
            int    nrZileEvenimenteDeosebiteLuna = 0;
            int    nrZileInvoireLuna             = 0;
            int    nrZileConcediuOdihnaLuna      = 0;

            float nrZileCOneefectuat   = 0;
            float nrZileCOefectInAvans = 0;

            int nrZileConcediuBoalaLuna      = 0;
            int nrZileConcediuBoalaLunaFirma = 0;
            int nrZileConcediuBoalaLunaBASS  = 0;

            int nrZileObligatiiCetatenesti = 0;
            int nrZileAbsenteNemotivate    = 0;
            int nrZileConcediuFaraPlata    = 0;

            int     nrZileLucratoareDelegatieInterna = 0;
            int     nrZileLucratoareDelegatieExterna = 0;
            decimal diurnaImpozabila            = 0;
            int     nrZileTotalDelegatieInterna = 0;
            int     nrZileTotalDelegatieExterna = 0;

            float nrOreLucrate         = 0;
            float nrOreSuplimentare50  = 0;
            float nrOreSuplimentare100 = 0;

            float [] salariuBaza           = new float[intervSL.Length];
            float [] indemnizatieConducere = new float[intervSL.Length];

            int nrZileEmergencyService = 0;

            int programLucru = 0;
            int invaliditate = 0;
            int categorieID  = 0;

            decimal angajatSporActivitateSupLuna = 0;
            decimal angajatEmergencyServiceLuna  = 0;
            decimal angajatPrimeSpecialeLuna     = 0;
            decimal angajatAlteDrepturiLuna      = 0;
            decimal angajatAlteDrepturiNetLuna   = 0;
            decimal angajatAjutorDeces           = 0;

            //S-au adaugat retinerile pentru un angajt
            decimal angajatAvansLuna            = 0;
            decimal angajatRetinere1            = 0;
            decimal angajatRetinere2            = 0;
            decimal angajatRetinere3            = 0;
            decimal angajatRetinere4            = 0;
            decimal angajatRetinere5            = 0;
            decimal angajatRetinere6            = 0;
            decimal angajatRetinere7            = 0;
            decimal angajatRegularizareLuna     = 0;
            decimal angajatPrimaProiectLuna     = 0;
            decimal angajatRetinereSanatateLuna = 0;
            decimal angajatDrepturiInNaturaLuna = 0;

            //Lungu Andreea
            float corectiiTicheteLuna = 0;

            int i = -1;

            foreach (Data.IntervaleSchimbariLuna interv in intervSL)
            {
                i++;

                nrZileLucratoareLuna[i] = pa.GetNrZileLucratoarePerioada(interv.DataStart, interv.DataEnd);

                TimeSpan nrOreLucrateLuna = pa.GetAngajatNrOreTipLucrate(interv.DataStart, interv.DataEnd, denumireOreLucrate[0]);

                TimeSpan nrOreSuplimentare50Luna  = pa.GetAngajatNrOreTipLucrate(interv.DataStart, interv.DataEnd, denumireOreLucrate[1]);
                TimeSpan nrOreSuplimentare100Luna = pa.GetAngajatNrOreTipLucrate(interv.DataStart, interv.DataEnd, denumireOreLucrate[2]);

                //tre facut pe intervale de timp si pt absente
                nrZileEvenimenteDeosebiteLuna += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[0]);
                nrZileInvoireLuna             += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[1]);
                nrZileConcediuOdihnaLuna      += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[2]) +
                                                 pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[11]);

                nrZileCOneefectuat   = isl.NrZileConcediuOdihnaNeefectuat;
                nrZileCOefectInAvans = isl.NrZileConcediuOdihnaEfectuatInAvans;

                nrZileConcediuBoalaLuna      += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[3]) + pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[4]);
                nrZileConcediuBoalaLunaFirma += pa.GetNrZileConcediuBoalaFirma(lunaID);
                nrZileConcediuBoalaLunaBASS  += pa.GetNrZileConcediuBoalaBASS(lunaID);

                nrZileObligatiiCetatenesti += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[5]);
                nrZileAbsenteNemotivate    += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[6]);
                nrZileConcediuFaraPlata    += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[7]);

                nrZileLucratoareDelegatieInterna += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[8]);
                nrZileLucratoareDelegatieExterna += pa.GetAngajatNrZileAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[9]);
                diurnaImpozabila             = isl.DiurnaImpozabila;
                nrZileTotalDelegatieInterna += pa.GetAngajatNrZileCuSarbatoriAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[8]);
                nrZileTotalDelegatieExterna += pa.GetAngajatNrZileCuSarbatoriAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[9]);

                nrZileEmergencyService += pa.GetAngajatNrZileCuSarbatoriAbsenteTipLuna(interv.DataStart, interv.DataEnd, codAbsente[10]);

                angajatSporActivitateSupLuna = isl.SporActivitatiSup;
                angajatEmergencyServiceLuna  = isl.EmergencyService;
                angajatPrimeSpecialeLuna     = isl.PrimeSpeciale;
                angajatAlteDrepturiLuna      = isl.AlteDrepturi;
                angajatAlteDrepturiNetLuna   = isl.AlteDrepturiNet;
                angajatAjutorDeces           = isl.AjutorDeces;

                angajatAvansLuna            = isl.Avans;
                angajatRetinere1            = isl.Retineri1;
                angajatRetinere2            = isl.Retineri2;
                angajatRetinere3            = isl.Retineri3;
                angajatRetinere4            = isl.Retineri4;
                angajatRetinere5            = isl.Retineri5;
                angajatRetinere6            = isl.Retineri6;
                angajatRetinere7            = isl.Retineri7;
                angajatRegularizareLuna     = isl.Regularizare;
                angajatPrimaProiectLuna     = isl.PrimaProiect;
                angajatRetinereSanatateLuna = isl.RetinereSanatate;
                angajatDrepturiInNaturaLuna = isl.DrepturiInNatura;

                nrOreLucrate         += nrOreLucrateLuna.Days * 24 + nrOreLucrateLuna.Hours + (float)nrOreLucrateLuna.Minutes / 60;
                nrOreSuplimentare50  += nrOreSuplimentare50Luna.Days * 24 + nrOreSuplimentare50Luna.Hours + (float)nrOreSuplimentare50Luna.Minutes / 60;
                nrOreSuplimentare100 += nrOreSuplimentare100Luna.Days * 24 + nrOreSuplimentare100Luna.Hours + (float)nrOreSuplimentare100Luna.Minutes / 60;

                //Lungu Andreea
                //nrTicheteLuna = isl.NrTichete;
                //daca angajatul e cu functia de baza aici si proportional cu programul de lucru
                //nrTicheteLuna = angajat.ProgramLucru * (nrOreLucrate - nrZileLucratoareDelegatieExterna - nrZileLucratoareDelegatieInterna) / 8;
                corectiiTicheteLuna = isl.CorectiiTichete;

                programLucru             = interv.ProgramLucru;
                salariuBaza[i]           = interv.SalariuBaza;
                indemnizatieConducere[i] = interv.IndemnizatieConducere;
                invaliditate             = interv.Invaliditate;
                categorieID = interv.CategorieID;
            }


            //este adaugata situatia lunara a angajatului in cauza
            Salaries.Data.InfoSituatieLunara x = new Salaries.Data.InfoSituatieLunara();

            x.SituatieID = -1;
            x.AngajatID  = this.AngajatID;
            x.LunaID     = lunaID;

            x.CategorieID  = categorieID;
            x.ProgramLucru = programLucru;
            //este calculat salariul de baza
            x.SalariuBaza = CalculSumaFinala(salariuBaza, nrZileLucratoareLuna, nrZileLucratoareLunaTotal);
            //este calculata indemnizatia de conducere
            x.IndemnizatieConducere = CalculSumaFinala(indemnizatieConducere, nrZileLucratoareLuna, nrZileLucratoareLunaTotal);
            x.Invaliditate          = invaliditate;

            x.NrZileLuna = CalculNrZileLucrate(nrZileLucratoareLuna);

            x.NrOreLucrate    = nrOreLucrate;
            x.NrOreSup50Proc  = nrOreSuplimentare50;
            x.NrOreSup100Proc = nrOreSuplimentare100;

            x.NrOreEvenimDeoseb   = nrZileEvenimenteDeosebiteLuna;
            x.NrOreInvoire        = nrZileInvoireLuna;
            x.NrOreConcediuOdihna = nrZileConcediuOdihnaLuna;

            x.NrZileConcediuOdihnaNeefectuat      = nrZileCOneefectuat;
            x.NrZileConcediuOdihnaEfectuatInAvans = nrZileCOefectInAvans;

            x.NrOreConcediuBoala      = nrZileConcediuBoalaLuna;
            x.NrOreConcediuBoalaFirma = nrZileConcediuBoalaLunaFirma;
            x.NrOreConcediuBoalaBASS  = nrZileConcediuBoalaLunaBASS;

            x.NrOreObligatiiCetatenesti = nrZileObligatiiCetatenesti;
            x.NrOreAbsenteNemotivate    = nrZileAbsenteNemotivate;
            x.NrOreConcediuFaraPlata    = nrZileConcediuFaraPlata;

            x.NrOreLucrateDelegatieInterna = nrZileLucratoareDelegatieInterna;
            x.NrOreLucrateDelegatieExterna = nrZileLucratoareDelegatieExterna;
            x.DiurnaImpozabila             = diurnaImpozabila;
            x.NrOreTotalDelegatieInterna   = nrZileTotalDelegatieInterna;
            x.NrOreTotalDelegatieExterna   = nrZileTotalDelegatieExterna;

            x.NrOreEmergencyService = nrZileEmergencyService;

            //Lungu Andreea - 31.08.2010
            //daca angajatul e cu functia de baza aici si proportional cu programul de lucru
            float nrOreLucrateFinal = x.NrOreLucrate + angajat.ProgramLucru * x.NrOreLucrateDelegatieInterna + angajat.ProgramLucru * x.NrOreLucrateDelegatieExterna;

            if (angajat.ModIncadrare == 0)
            {
                x.NrTichete = angajat.ProgramLucru * (nrOreLucrateFinal / angajat.ProgramLucru - x.NrOreLucrateDelegatieExterna - x.NrOreLucrateDelegatieInterna) / 8;
            }
            else
            {
                x.NrTichete = 0;
            }
            x.CorectiiTichete = corectiiTicheteLuna;
            //nr total tichete
            x.NrTotalTichete = (int)Math.Ceiling(x.NrTichete + x.CorectiiTichete);
            if (x.NrTotalTichete < 0)
            {
                //x.NrTotalTichete = (int) Math.Ceiling(x.NrTichete);
                x.NrTotalTichete = 0;
            }

            x.SporActivitatiSup = Convert.ToDecimal(angajatSporActivitateSupLuna);
            x.EmergencyService  = Convert.ToDecimal(angajatEmergencyServiceLuna);
            x.PrimeSpeciale     = Convert.ToDecimal(angajatPrimeSpecialeLuna);
            x.AlteDrepturi      = Convert.ToDecimal(angajatAlteDrepturiLuna);
            x.AlteDrepturiNet   = Convert.ToDecimal(angajatAlteDrepturiNetLuna);
            x.AjutorDeces       = Convert.ToDecimal(angajatAjutorDeces);

            x.Avans            = Convert.ToDecimal(angajatAvansLuna);
            x.Retineri1        = Convert.ToDecimal(angajatRetinere1);
            x.Retineri2        = Convert.ToDecimal(angajatRetinere2);
            x.Retineri3        = Convert.ToDecimal(angajatRetinere3);
            x.Retineri4        = Convert.ToDecimal(angajatRetinere4);
            x.Retineri5        = Convert.ToDecimal(angajatRetinere5);
            x.Retineri6        = Convert.ToDecimal(angajatRetinere6);
            x.Retineri7        = Convert.ToDecimal(angajatRetinere7);
            x.Regularizare     = Convert.ToDecimal(angajatRegularizareLuna);
            x.PrimaProiect     = Convert.ToDecimal(angajatPrimaProiectLuna);
            x.RetinereSanatate = Convert.ToDecimal(angajatRetinereSanatateLuna);
            x.DrepturiInNatura = Convert.ToDecimal(angajatDrepturiInNaturaLuna);

            /*
             * Modified: Cristina Raluca Muntean
             * Date:     13.09.2005
             * A fost facuta aceasta modificare deoarece daca se lichida angajatul din prima zi, deci
             * nu se mai putea genera situatia lunara pe baza pontajului, atunci la adaugare era aruncata
             * o exceptie si ramanea vechea situatie.
             */

            //In cazul in care nu exista date pentru situatia lunara, aceasta se
            //sterge(aceasta se poate intampla daca a fost lichidat angajatul din prima zi a lunii).
            if ((x.NrZileLuna == 0) && (x.CategorieID == 0) && (x.ProgramLucru == 0))
            {
                this.DeleteSituatieAngajat(int.Parse(x.LunaID.ToString()), int.Parse(x.AngajatID.ToString()));
            }
            else
            {
                //Daca exista date pentru situatia lunara, atunci se sterge vechea situatie
                //lunara si se adauga situatia cu noile date.
                this.AddSituatieLunaraAngajat(x, validareStergere);
                validareStergere = false;
            }
            //}
            //catch
            //{}
        }