/// <summary>
        /// Sterge o intrerupere CIM
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStergeDate_Click()
        {
            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - start - StergeRetinere() - angID: " + AngajatID + " - " + txtDataStart.Text + " - " + txtDataEnd.Text);
            int retinereId = Convert.ToInt32(txtRetinereID.Value);

            Salaries.Business.RetineriRecurenteAngajat ret = new Salaries.Business.RetineriRecurenteAngajat();
            ret.GetRetinere(retinereId);
            DateTime dataStart = ret.RetAng.DataInceput;
            DateTime dataEnd   = ret.RetAng.DataSfarsit;
            DateTime data1     = new DateTime(dataStart.Year, dataStart.Month, 1);
            DateTime data2;

            if (dataEnd.Month != 12)
            {
                data2 = new DateTime(dataEnd.Year, dataEnd.Month + 1, 1);
                data2 = data2.AddDays(-1);
            }
            else
            {
                data2 = new DateTime(dataEnd.Year, dataEnd.Month, 31);
            }

            if (data1.CompareTo(ret.RetAng.DataInceput) != 0 && data1 < dataStartLunaActiva)
            {
                Response.Write("<script> alert('Nu se pot modifica retinerile pentru lunile anterioare'); </script>");
                return;
            }
            //if (data1.CompareTo(ret.RetAng.DataInceput) >= 0 && data2 >= dataStartLunaActiva )
            if ((data1.CompareTo(ret.RetAng.DataInceput) > 0 || (data1.CompareTo(ret.RetAng.DataInceput) == 0 && (data1.CompareTo(dataStartLunaActiva) < 0))) &&
                data2 >= dataStartLunaActiva)
            {
                Response.Write("<script> alert('Se va updata intervalul astfel incat sa ramana doar perioada dinaintea lunii active.'); </script>");
                //se face update la retinerea deja existenta...se modifica data sfarsit si anume pana la luna activa
                ret.RetAng.DataSfarsit = dataStartLunaActiva.AddDays(-1);
                ret.UpdateRetinereRecurentaAngajat();
                LoadRetineriAngajat();
                this.txtDataStart.Text = "";
                this.txtDataEnd.Text   = "";
                return;
            }

            //daca am perioada activa trebuie sa modific valorile retinerilor
            //actualizarea retinerilor
            if (ret.RetAng.DataInceput <= dataStartLunaActiva && dataStartLunaActiva <= ret.RetAng.DataSfarsit)
            {
                Salaries.Business.TipuriRetineriValori tipuri = new Salaries.Business.TipuriRetineriValori();
                tipuri.UpdateValoareRetinere((int)lunaID, AngajatID, ret.RetAng.TipRetinere, 0);
            }
            ret.DeleteRetinereRecurentaAngajat();

            Salaries.Business.SituatieLunaraAngajat sitAngajat = new Salaries.Business.SituatieLunaraAngajat(AngajatID);
            sitAngajat.GenerareSituatieLunaraAngajat((int)AngajatID, (int)lunaID);

            LoadRetineriAngajat();
            this.txtDataStart.Text = "";
            this.txtDataEnd.Text   = "";

            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - end - StergeRetinere() - angID: " + AngajatID);
        }
        /// <summary>
        /// Adauga o retinere
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAdauga_Click()
        {
            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - start - AdaugaRetinere() - angID: " + AngajatID + " - " + txtDataStart.Text + " - " + txtDataEnd.Text);
            try
            {
                DateTime dataStart        = SiemensTM.utils.Utilities.ConvertText2DateTime(txtDataStart.Text /*DateStart.Value*/);
                DateTime dataEnd          = SiemensTM.utils.Utilities.ConvertText2DateTime(txtDataEnd.Text /*DateEnd.Value*/);
                string   denumireRetinere = txtRetinere.Text;
                decimal  valoare          = decimal.Parse(txtValoare.Text);
                string   tipRetinere      = ddlTipuriRetineri.SelectedValue;
                bool     alerta           = chkAlerta.Checked;
                int      retinereId       = Convert.ToInt32(txtRetinereID.Value);

                DateTime data1 = new DateTime(dataStart.Year, dataStart.Month, 1);
                DateTime data2;
                if (dataEnd.Month != 12)
                {
                    data2 = new DateTime(dataEnd.Year, dataEnd.Month + 1, 1);
                    data2 = data2.AddDays(-1);
                }
                else
                {
                    data2 = new DateTime(dataEnd.Year, dataEnd.Month, 31);
                }
                //data de start as cam vrea sa fie in luna activa pentru a nu avea probleme cu legaturile catre tipul de retinere
                if (data1 != dataStartLunaActiva || data2 < dataStartLunaActiva)
                {
                    Response.Write("<script> alert('Data de inceput trebuie sa fie in luna activa si data de sfarsit trebuie sa fie dupa data de inceput!'); </script>");
                    return;
                }

                //sa verific daca pot adauga, daca nu exista inca o retinere cu acelasi tip de retinere si perioada intersectatat
                Salaries.Business.RetineriRecurenteAngajat ret = new Salaries.Business.RetineriRecurenteAngajat();
                ret.RetAng.AngajatID        = AngajatID;
                ret.RetAng.IdRetinere       = retinereId;
                ret.RetAng.TipRetinere      = tipRetinere;
                ret.RetAng.DenumireRetinere = denumireRetinere;
                ret.RetAng.DataInceput      = data1;
                ret.RetAng.DataSfarsit      = data2;
                ret.RetAng.Valoare          = valoare;
                ret.RetAng.Alerta           = alerta;
                if (ret.VerificaIntersectieNrRetineri() == 0)
                {
                    ret.InsertRetinereRecurentaAngajat();
                }
                else
                {
                    Response.Write("<script> alert('Nu se poate introduce acelasi tip de retinere pentru perioade ce se intersecteaza!'); </script>");
                }

                //daca am perioada activa trebuie sa modific valorile retinerilor
                //actualizarea retinerilor
                if (ret.RetAng.DataInceput <= dataStartLunaActiva && dataStartLunaActiva <= ret.RetAng.DataSfarsit)
                {
                    Salaries.Business.TipuriRetineriValori tipuri = new Salaries.Business.TipuriRetineriValori();
                    tipuri.UpdateValoareRetinere((int)lunaID, AngajatID, ret.RetAng.TipRetinere, ret.RetAng.Valoare);
                }

                Salaries.Business.SituatieLunaraAngajat sitAngajat = new Salaries.Business.SituatieLunaraAngajat(AngajatID);
                sitAngajat.GenerareSituatieLunaraAngajat((int)AngajatID, (int)lunaID);

                LoadRetineriAngajat();
                this.txtDataStart.Text = "";
                this.txtDataEnd.Text   = "";
            }
            catch (Exception ex)
            {
                litError.Text  = "The following error occurred: <br>";
                litError.Text += ex.Message;
                ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - error - - angID: " + AngajatID + " - " + ex.Message);
            }
            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - end - AdaugaRetinere() - angID: " + AngajatID);
        }
        /// <summary>
        /// Modifica o intrerupere CIM
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnModificaDate_Click()
        {
            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - start - ModificaRetinere() - angID: " + AngajatID + " - " + txtDataStart.Text + " - " + txtDataEnd.Text);
            try
            {
                int retinereId = Convert.ToInt32(txtRetinereID.Value);
                Salaries.Business.RetineriRecurenteAngajat ret = new Salaries.Business.RetineriRecurenteAngajat();
                ret.GetRetinere(retinereId);
                Salaries.Business.RetineriRecurenteAngajat retinereVeche = ret;
                DateTime dataStart        = SiemensTM.utils.Utilities.ConvertText2DateTime(txtDataStart.Text /*DateStart.Value*/);
                DateTime dataEnd          = SiemensTM.utils.Utilities.ConvertText2DateTime(txtDataEnd.Text /*DateEnd.Value*/);
                string   tipRetinere      = ddlTipuriRetineri.SelectedValue;
                string   denumireRetinere = txtRetinere.Text;
                decimal  valoare          = decimal.Parse(txtValoare.Text);
                bool     alerta           = chkAlerta.Checked;
                DateTime data1            = new DateTime(dataStart.Year, dataStart.Month, 1);
                DateTime data2;
                if (dataEnd.Month != 12)
                {
                    data2 = new DateTime(dataEnd.Year, dataEnd.Month + 1, 1);
                    data2 = data2.AddDays(-1);
                }
                else
                {
                    data2 = new DateTime(dataEnd.Year, dataEnd.Month, 31);
                }

                //daca noile date sunt inaintea lunii active
                if (data1.CompareTo(ret.RetAng.DataInceput) != 0 && data1 < dataStartLunaActiva)
                {
                    Response.Write("<script> alert('Nu se pot modifica retinerile pentru lunile anterioare') </script>");
                    return;
                }
                if ((data1.CompareTo(ret.RetAng.DataInceput) > 0 || (data1.CompareTo(ret.RetAng.DataInceput) == 0 && (data1.CompareTo(dataStartLunaActiva) < 0))) &&
                    data2 >= dataStartLunaActiva && valoare != ret.RetAng.Valoare)
                {
                    Response.Write("<script> alert('Se vor realiza doua intervale separate pentru ca difera valorile retinerii pentru lunile anterioare si cele viitoare'); </script>");
                    //se face update la retinerea deja existenta...se modifica data sfarsit si anume pana la luna activa
                    ret.RetAng.DataSfarsit = dataStartLunaActiva.AddDays(-1);
                    ret.UpdateRetinereRecurentaAngajat();
                    //se adauga o noua inregistrare cu noua retinere
                    ret.RetAng.AngajatID        = AngajatID;
                    ret.RetAng.IdRetinere       = 0;
                    ret.RetAng.TipRetinere      = tipRetinere;
                    ret.RetAng.DenumireRetinere = denumireRetinere;
                    ret.RetAng.DataInceput      = dataStartLunaActiva;
                    ret.RetAng.DataSfarsit      = data2;
                    ret.RetAng.Valoare          = valoare;
                    ret.RetAng.Alerta           = alerta;
                    ret.InsertRetinereRecurentaAngajat();

                    //daca am perioada activa trebuie sa modific valorile retinerilor
                    //actualizarea retinerilor
                    if (ret.RetAng.DataInceput <= dataStartLunaActiva && dataStartLunaActiva <= ret.RetAng.DataSfarsit)
                    {
                        Salaries.Business.TipuriRetineriValori tipuri = new Salaries.Business.TipuriRetineriValori();
                        tipuri.UpdateValoareRetinere((int)lunaID, AngajatID, ret.RetAng.TipRetinere, ret.RetAng.Valoare);
                    }

                    LoadRetineriAngajat();
                    this.txtDataStart.Text = "";
                    this.txtDataEnd.Text   = "";
                    return;
                }

                // in rest	se face modificare...inseamna ca se modifica doar alerta sau datele astfel incat sa nu influeneteze
                ret = new Salaries.Business.RetineriRecurenteAngajat();
                ret.RetAng.AngajatID        = AngajatID;
                ret.RetAng.IdRetinere       = retinereId;
                ret.RetAng.TipRetinere      = tipRetinere;
                ret.RetAng.DenumireRetinere = denumireRetinere;
                ret.RetAng.DataInceput      = data1;
                ret.RetAng.DataSfarsit      = data2;
                ret.RetAng.Valoare          = valoare;
                ret.RetAng.Alerta           = alerta;
                ret.UpdateRetinereRecurentaAngajat();

                //daca am perioada activa trebuie sa modific valorile retinerilor
                //actualizarea retinerilor
                if (ret.RetAng.DataInceput <= dataStartLunaActiva && dataStartLunaActiva <= ret.RetAng.DataSfarsit && retinereVeche.RetAng.Valoare != ret.RetAng.Valoare)
                {
                    Salaries.Business.TipuriRetineriValori tipuri = new Salaries.Business.TipuriRetineriValori();
                    tipuri.UpdateValoareRetinere((int)lunaID, AngajatID, ret.RetAng.TipRetinere, ret.RetAng.Valoare);
                }

                Salaries.Business.SituatieLunaraAngajat sitAngajat = new Salaries.Business.SituatieLunaraAngajat(AngajatID);
                sitAngajat.GenerareSituatieLunaraAngajat((int)AngajatID, (int)lunaID);

                LoadRetineriAngajat();
                this.txtDataStart.Text = "";
                this.txtDataEnd.Text   = "";
            }
            catch (Exception ex)
            {
                litError.Text  = "The following error occurred: <br>";
                litError.Text += ex.Message;
                ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - error - ModificaRetinere() - angID: " + AngajatID + " - " + ex.Message);
            }
            ErrHandler.MyErrHandler.WriteError("RetineriAngajat.ascx - end - ModificaRetinere() - angID: " + AngajatID);
        }
        /// <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()");
        }