예제 #1
0
        /// <summary>
        /// Metoda ustawiania godzin pracy pracownika.
        /// </summary>
        /// <param name="form">Formularz wywołujący</param>
        /// <param name="hours">Tablica 14 elementów zawierająca godziny rozpoczęcia i zakończenia pracy
        /// w kolejnych dniach tygodnia. Np. hours[0] == godzina rozpoczęcia pracy w poniedziałek, 
        /// hours[1] == godzina zakończenia pracy w poniedziałek,
        /// hours[2] == godzina rozpoczęcia pracy we wtorek itd.
        /// 
        /// Format godziny to dd:mm:[ss[.nnnnnnn]]</param>
        /// <param name="employeeId">Numer id pracownika, któremu zmieniamy harmonogram.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentException">Występuje w przypadku próby odjęcia większej liczby dni, niż pracownik posiada.</exception>
        private static void SetSchedule(LeaveManagerForm form, string[] hours, int employeeId)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                if (hours.Length != 14)
                {
                    throw new ArgumentException();
                }
                using (SqlCommand command = new SqlCommand("UPDATE Work_hours " +
                    "SET " +
                    "MondayStart = @MondayStart, " +
                    "MondayEnd = @MondayEnd, " +

                    "TuesdayStart = @TuesdayStart, " +
                    "TuesdayEnd = @TuesdayEnd, " +

                    "WednesdayStart = @WednesdayStart, " +
                    "WednesdayEnd = @WednesdayEnd, " +

                    "ThursdayStart = @ThursdayStart, " +
                    "ThursdayEnd = @ThursdayEnd, " +

                    "FridayStart = @FridayStart, " +
                    "FridayEnd = @FridayEnd, " +

                    "SaturdayStart = @SaturdayStart, " +
                    "SaturdayEnd = @SaturdayEnd, " +

                    "SundayStart = @SundayStart, " +
                    "SundayEnd = @SundayEnd " +
                    "WHERE Employee_ID = @Employee_ID", form.Connection, form.Transaction))
                {
                    command.Parameters.AddWithValue("@MondayStart", hours[0]);
                    command.Parameters.AddWithValue("@MondayEnd", hours[1]);

                    command.Parameters.AddWithValue("@TuesdayStart", hours[2]);
                    command.Parameters.AddWithValue("@TuesdayEnd", hours[3]);

                    command.Parameters.AddWithValue("@WednesdayStart", hours[4]);
                    command.Parameters.AddWithValue("@WednesdayEnd", hours[5]);

                    command.Parameters.AddWithValue("@ThursdayStart", hours[6]);
                    command.Parameters.AddWithValue("@ThursdayEnd", hours[7]);

                    command.Parameters.AddWithValue("@FridayStart", hours[8]);
                    command.Parameters.AddWithValue("@FridayEnd", hours[9]);

                    command.Parameters.AddWithValue("@SaturdayStart", hours[10]);
                    command.Parameters.AddWithValue("@SaturdayEnd", hours[11]);

                    command.Parameters.AddWithValue("@SundayStart", hours[12]);
                    command.Parameters.AddWithValue("@SundayEnd", hours[13]);

                    command.Parameters.AddWithValue("@Employee_ID", employeeId);

                    command.ExecuteNonQuery();
                }
                RecountLeaveDays(form, employeeId);
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #2
0
        /// <summary>
        /// Metoda edytująca wpis urlopowy.
        /// </summary>
        /// <param name="form">Formularz potrzebujący metody.</param>
        /// <param name="leave">Obiekt urlopu wpisany w miejsce starego wpisu.</param>
        /// <param name="editedLeaveId">Numer id edytowanego wpisu urlopowego.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentException">Występuje w przypadku próby wzięcia pracownikowi większej liczby dni, niż posiada.</exception> 
        private static void EditLeave(LeaveManagerForm form, Leave leave)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
            * o odpowiednim poziomie izolacji.
            */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Zczytanie podmienianego urlopu.
                Leave oldLeave = GetLeave(form, leave.Id);
                //Jeżeli wpisywany urlop konsumuje dni urlopowe.
                if (ConsumesDays(form, leave.LeaveType))
                {
                    leave.UsedDays = GetNumberOfWorkDays(form, leave.FirstDay, leave.LastDay, leave.EmployeeId);
                    //Obliczenie różnicy o którą trzeba zmienić liczbę dni urlopowych pracownika.
                    int difference = oldLeave.UsedDays - leave.UsedDays;
                    AddLeaveDays(form, leave.EmployeeId, difference);
                }
                else//Nowy urlop nie konsumuje dni.
                {
                    leave.UsedDays = 0;
                    //Jeżeli stary urlop konsumuje dni.
                    if (ConsumesDays(form, oldLeave.LeaveType))
                        //Dodajemy pracownikowi tyle dni, ile stary urlop konsumował.
                        AddLeaveDays(form, leave.EmployeeId, oldLeave.UsedDays);
                }
                //Polecenie sql aktualizujące wszystkie dane w starym wpisie.
                SqlCommand commandUpdate = new SqlCommand("UPDATE Leave SET LT_ID = (SELECT LT_ID FROM Leave_type WHERE Name = @Leave_type_name), LS_ID = " +
                   "(SELECT ST_ID FROM Status_type WHERE Name = @Status_name), " +
                   "First_day = @First_day, Last_day = @Last_day, Remarks = @Remarks, Used_days = @Used_days " +
                   "WHERE Leave_ID = @OldLeave_ID", form.Connection, form.Transaction);
                commandUpdate.Parameters.Add("@OldLeave_ID", SqlDbType.Int).Value = leave.Id;
                //Jeżeli wpisywany urlop jest chorobowym, to niezależnie od ustawionego stanu jest ustawiony stan zatwierdzony.
                if (leave.LeaveStatus.Equals("Sick"))
                {
                    commandUpdate.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = "Approved";
                }
                else
                {
                    if (leave.LeaveStatus.Equals("Extraordinary"))
                    {
                    }
                    else
                    {
                        commandUpdate.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = leave.LeaveStatus;
                    }
                }
                commandUpdate.Parameters.Add("@Employee_ID", SqlDbType.Int).Value = leave.EmployeeId;
                commandUpdate.Parameters.Add("@Leave_type_name", SqlDbType.VarChar).Value = leave.LeaveType;
                commandUpdate.Parameters.Add("@First_day", SqlDbType.Date).Value = leave.FirstDay;
                commandUpdate.Parameters.Add("@Last_day", SqlDbType.Date).Value = leave.LastDay;
                commandUpdate.Parameters.Add("@Remarks", SqlDbType.VarChar).Value = leave.Remarks;
                commandUpdate.Parameters.Add("@Used_days", SqlDbType.Int).Value = leave.UsedDays;
                commandUpdate.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #3
0
        /// <summary>
        /// Metoda służąca do odrzucania zgłoszeń urlopowych.
        /// </summary>
        /// <param name="form">Formularz wywołujący.</param>
        /// <param name="rejectedLeaveId">Numer id odrzucanego urlopu.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        private static void RejectLeave(LeaveManagerForm form, int rejectedLeaveId)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                Leave rejectedLeave = GetLeave(form, rejectedLeaveId);
                //Polecenie sql służące do aktualizacji stanu zgłoszenia.
                SqlCommand command = new SqlCommand("UPDATE Leave SET LS_ID = (SELECT ST_ID FROM " +
                    "Status_type WHERE Name = @Name), Used_days = @Used_days WHERE Leave_ID = @Leave_ID", form.Connection,
                    form.Transaction);
                command.Parameters.Add("@Used_days", SqlDbType.Int).Value = 0;
                command.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = rejectedLeave.Id;
                command.Parameters.Add("@Name", SqlDbType.VarChar).Value = "Rejected";
                command.ExecuteNonQuery();
                AddLeaveDays(form, rejectedLeave.EmployeeId, rejectedLeave.UsedDays);
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #4
0
        /// <summary>
        /// Metoda służąca do usunięcia z bazy danych typu pozycji pracowników.
        /// </summary>
        /// <param name="form">Formularz wywołujący metodę.</param>
        /// <param name="replacementPosition">Pozycja, która zostanie przypisana wszystkim pracownikom, którzy zajmują pozycję usuwaną.</param>
        /// <param name="deletedPosition">Nazwa pozycji usuwanej.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Występuje w przypadku, gdy w bazie nie istnieje replacementPosition.</exception>
        private static void DeletePosition(LeaveManagerForm form, string replacementPosition, string deletedPosition)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Zapytanie sql zczytujące id pozycji, która ma zastąpić miejsce usuwanej.
                SqlCommand commandCheckReplacedPosition = new SqlCommand("SELECT Position_ID FROM " +
                    "Position WHERE Description = @Description", form.Connection, form.Transaction);
                commandCheckReplacedPosition.Parameters.Add("@Description", SqlDbType.VarChar).Value = replacementPosition;
                SqlDataReader reader = commandCheckReplacedPosition.ExecuteReader();
                //Sprawdzenie, czy zastępująca pozycja istnieje.
                if (reader.Read())
                {
                    //Polecenie aktualizacji pozycji wszystkich pracowników, którzy zajmują pozycję usuwaną.
                    SqlCommand commandUpdate = new SqlCommand("UPDATE Employee SET Position_ID = " +
                        "@ReplacementPosition_ID " +
                        "WHERE Position_ID = " +
                        "(SELECT Position_ID FROM Position WHERE Description = @Description_replaced)", form.Connection, form.Transaction);
                    commandUpdate.Parameters.Add("@ReplacementPosition_ID", SqlDbType.Int).Value = (int)reader["Position_ID"];
                    reader.Close();
                    commandUpdate.Parameters.Add("@Description_replaced", SqlDbType.VarChar).Value = deletedPosition;
                    commandUpdate.ExecuteNonQuery();
                    //Polecenie usunięcia rodzaju pozycji przeznaczonego do usunięcia.
                    SqlCommand commandDelete = new SqlCommand("DELETE FROM Position WHERE " +
                        "Description = @Description", form.Connection, form.Transaction);
                    commandDelete.Parameters.Add("@Description", SqlDbType.VarChar).Value = deletedPosition;
                    commandDelete.ExecuteNonQuery();
                }
                else
                {
                    reader.Close();
                    throw new ArgumentOutOfRangeException();
                }
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #5
0
        /// <summary>
        /// Metoda usuwania daty z tabeli dni wolnych od pracy.
        /// </summary>
        /// <param name="form">Formularz wywołujący</param>
        /// <param name="date">Usuwana data.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        private static void DeletePublicHoliday(LeaveManagerForm form, DateTime date)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                using (SqlCommand command = new SqlCommand("DELETE FROM Public_holidays WHERE Date = @Date", form.Connection))
                {
                    if (form.TransactionOn)
                    {
                        command.Transaction = form.Transaction;
                    }
                    command.Parameters.AddWithValue("@Date", date);
                    command.ExecuteNonQuery();
                }

                DataTable employees = GetEmployees(form);
                for (int i = 0; i < employees.Rows.Count; ++i)
                {
                    RecountLeaveDays(form, (int)employees.Rows[i].ItemArray.GetValue(0));
                }
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #6
0
        /// <summary>
        /// Metoda służąca do usuwania z bazy danych danego typu urlopu.
        /// </summary>
        /// <param name="form">Formularz wywołujący metodę.</param>
        /// <param name="replacementType">Nazwa typu urlopu, który będzie wpisany jako typ urlopów, które są typu usuwanego.</param>
        /// <param name="deletedType">Nazwa usuwanego typu urlopu.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Występuje w przypadku, gdy w bazie nie istnieje replacementType.</exception>
        private static void DeleteLeaveType(LeaveManagerForm form, string replacementType, string deletedType)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Zapytanie sql zczytujące id typu, który ma zastąpić usuwany typ.
                SqlCommand commandCheckReplaceType = new SqlCommand("SELECT LT_ID FROM Leave_type WHERE Name = @Name",
                    form.Connection, form.Transaction);
                commandCheckReplaceType.Parameters.Add("@Name", SqlDbType.VarChar).Value = replacementType;
                SqlDataReader reader = commandCheckReplaceType.ExecuteReader();
                if (reader.Read())//Sprawdzenie, czy typ, na który zamieniamy typ usuwany w ogóle istnieje.
                {
                    //Polecenie sql aktualizujące typy wszystkich urlopów, które są usuwanego typu.
                    SqlCommand commandUpdate = new SqlCommand("UPDATE Leave SET LT_ID = " +
                        "@ReplacementLT_ID " +
                        "WHERE LT_ID = " +
                        "(SELECT LT_ID FROM Leave_type WHERE Name = @Name_replaced)", form.Connection, form.Transaction);
                    commandUpdate.Parameters.Add("@ReplacementLT_ID", SqlDbType.Int).Value = (int)reader["LT_ID"];
                    reader.Close();
                    commandUpdate.Parameters.Add("@Name_replaced", SqlDbType.VarChar).Value = deletedType;
                    commandUpdate.ExecuteNonQuery();
                    //Polecenie sql usuwające typ do usunięcia.
                    SqlCommand commandDelete = new SqlCommand("DELETE FROM Leave_type WHERE " +
                        "Name = @Name", form.Connection, form.Transaction);
                    commandDelete.Parameters.Add("@Name", SqlDbType.VarChar).Value = deletedType;
                    commandDelete.ExecuteNonQuery();
                }
                else
                {
                    reader.Close();
                    throw new ArgumentOutOfRangeException();
                }
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #7
0
        /// <summary>
        /// Metoda służąca do usuwania z bazy danych danego typu urlopu.
        /// </summary>
        /// <param name="form">Formularz wywołujący metodę.</param>
        /// <param name="deletedType">Nazwa usuwanego typu urlopu.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        private static void DeleteLeaveType(LeaveManagerForm form, LeaveType deletedType)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                SqlCommand commandGetLeavesToDelete = new SqlCommand("SELECT L.Leave_ID, L.Employee_ID, LS.Name AS 'Status', " +
                    "L.First_day, L.Last_day, L.Remarks, L.Used_days FROM Leave L, Status_type LS WHERE " +
                    "L.LS_ID = LS.ST_ID AND L.LT_ID = @LT_ID",
                    form.Connection, form.Transaction);
                commandGetLeavesToDelete.Parameters.AddWithValue("@LT_ID", deletedType.Id);
                SqlDataReader reader = commandGetLeavesToDelete.ExecuteReader();
                List<Leave> leaveEntriesToDelete = new List<Leave>();
                while (reader.Read())
                {
                    leaveEntriesToDelete.Add(new Leave((int)reader["Leave_ID"], (int)reader["Employee_ID"], deletedType.Name,
                       reader["Status"].ToString(), (DateTime)reader["First_day"],
                       (DateTime)reader["Last_day"], reader["Remarks"].ToString(), (int)reader["Used_days"]));
                }
                reader.Close();
                foreach (Leave leave in leaveEntriesToDelete)
                {
                    DeleteLeave(form, leave.Id);
                }
                SqlCommand commandDeleteType = new SqlCommand("DELETE FROM Leave_type WHERE LT_ID = @LT_ID",
                    form.Connection, form.Transaction);
                commandDeleteType.Parameters.AddWithValue("@LT_ID", deletedType.Id);
                commandDeleteType.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #8
0
        /// <summary>
        /// Dodanie chorobowego.
        /// </summary>
        /// <param name="form">Formularz potrzebujący metody.</param>
        /// <param name="leave">Obiekt reprezentujący dodawany urlop.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        private static void AddSickLeave(LeaveManagerForm form, Leave leave)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
               * o odpowiednim poziomie izolacji.
               */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Zczytanie urlopów pracownika, któremu dodajemy chorobowe.
                /// Kolumny tabeli: "Leave Id", "Status", "First day", "Last day", "Type",
                /// "Remarks", "No. used days"
                DataTable dataLeaves = GetLeaves(form, leave.EmployeeId);

                /* Zmienna w której będzie przechowywana liczba dni do zwrócenia pracownikowi.
                 * Powiększa się w przypadku, gdy chorobowe zachodzi na jakiś urlop.
                 */
                int returnedLeaveDays = 0;
                int returnedDemandedDays = 0;
                //Dla każdego istniejącego w bazie urlopu.
                foreach (DataRow row in dataLeaves.Rows)
                {
                    //Pierwszy dzień sprawdzanego urlopu jest później lub ten sam, co pierwszy dzień chorobowego
                    if ((((DateTime)row.ItemArray.GetValue(2)).CompareTo(leave.FirstDay) >= 0)
                        //i jest wcześniej lub taki sam jak ostatni dzień chorobowego.
                    && (((DateTime)row.ItemArray.GetValue(2)).CompareTo(leave.LastDay) <= 0))
                    {//Czyli w praktyce: Zaczyna się w trakcie chorobowego -> jest anulowany.
                        //Jeżeli zachodzący wpis to chorobowe.
                        if (row.ItemArray.GetValue(4).ToString().Equals("Sick"))
                            throw new EntryExistsException();
                        //Polecenie sql zmieniające stan zachodzącego urlopu na anulowany.
                        SqlCommand commandUpdateLeave = new SqlCommand("UPDATE Leave SET " +
                           "LS_ID = (SELECT ST_ID FROM Status_type WHERE Name = @Status_name), Used_days = @Used_days " +
                           "WHERE Leave_ID = @Leave_ID", form.Connection, form.Transaction);
                        commandUpdateLeave.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = "Canceled";
                        commandUpdateLeave.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = (int)row.ItemArray.GetValue(0);
                        commandUpdateLeave.Parameters.Add("@Used_days", SqlDbType.Int).Value = 0;
                        commandUpdateLeave.ExecuteNonQuery();
                        //Dodanie do liczby dni do zwrócenia pracownikowi dni anulowanego urlopu.
                        returnedLeaveDays += (int)row.ItemArray.GetValue(6);
                        if (row.ItemArray.GetValue(4).ToString().Equals("Extraordinary"))
                        {
                            returnedDemandedDays += (int)row.ItemArray.GetValue(6);
                        }
                        continue;
                    }

                    if ((leave.FirstDay.CompareTo((DateTime)row.ItemArray.GetValue(2)) >= 0)//Sick first day later than leave first day
                    && (leave.FirstDay.CompareTo((DateTime)row.ItemArray.GetValue(3)) <= 0))//and earlier than leave last day.
                    {//Czyli w praktyce: Kończy się w trakcie chorobowego -> jest 'przycinany' do ostatniego dnia przed chorobowym.
                        SqlCommand commandUpdateLeave = new SqlCommand("UPDATE Leave SET " +
                            "Last_day = @Last_day, Used_days = @Used_days WHERE Leave_ID = @Leave_ID", form.Connection, form.Transaction);
                        commandUpdateLeave.Parameters.Add("@Last_day", SqlDbType.Date).Value = leave.FirstDay.AddDays(-1);
                        commandUpdateLeave.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = (int)row.ItemArray.GetValue(0);
                        //Nowa liczba użytych dni to liczba użytych dni pomiędzy pierwszym dniem zmienianego urlopu i pierwszym-1 dniem chorobowego.
                        commandUpdateLeave.Parameters.Add("@Used_days", SqlDbType.Int).Value =
                            GetNumberOfWorkDays(form, (DateTime)row.ItemArray.GetValue(2), leave.FirstDay.AddDays(-1), leave.EmployeeId);
                        commandUpdateLeave.ExecuteNonQuery();
                        int tmpReturnedDays = GetNumberOfWorkDays(form, leave.FirstDay.AddDays(-1), (DateTime)row.ItemArray.GetValue(1), leave.EmployeeId);
                        //Dodanie do liczby dni do zwrócenia pracownikowi liczby dni za okres od początku chorobowego do końca urlopu.
                        returnedLeaveDays += GetNumberOfWorkDays(form, leave.FirstDay.AddDays(-1), (DateTime)row.ItemArray.GetValue(1), leave.EmployeeId);
                        //Jeżeli urlop był na żądanie.
                        if (row.ItemArray.GetValue(4).ToString().Equals("Extraordinary"))
                        {
                            returnedDemandedDays += tmpReturnedDays;
                        }
                        continue;
                    }
                }
                //Zwrócenie pracownikowi dni.
                AddLeaveDays(form, leave.EmployeeId, returnedLeaveDays);
                AddDemandDays(form, leave.EmployeeId, -returnedDemandedDays);
                //Dodanie urlopu.
                AddLeave(form, leave);
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #9
0
        /// <summary>
        /// Metoda usuwania wpisu urlopowego.
        /// </summary>
        /// <param name="form">Formularz potrzebujący metody.</param>
        /// <param name="leaveId">Numer id usuwanego wpisu urlopowego.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        private static void DeleteLeave(LeaveManagerForm form, int leaveId)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
            * o odpowiednim poziomie izolacji.
            */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                Leave leave = GetLeave(form, leaveId);
                //Polecenie sql usuwające wpis urlopowy.
                SqlCommand commandDeleteLeave = new SqlCommand("DELETE FROM Leave WHERE Leave_ID = @Leave_ID",
                    form.Connection, form.Transaction);
                commandDeleteLeave.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = leave.Id;
                commandDeleteLeave.ExecuteNonQuery();
                AddLeaveDays(form, leave.EmployeeId, leave.UsedDays);
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #10
0
        /// <summary>
        /// Metoda dodająca nowy rodzaj pozycji (pracowników) do bazy.
        /// </summary>
        /// <param name="form">Formularz wywołujący metodę.</param>
        /// <param name="name">Nazwa nowej pozycji.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="EntryExists">Występuje w przypadku próby dodania istniejącej pozycji.</exception>
        private static void AddPositionType(LeaveManagerForm form, string name)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
              * o odpowiednim poziomie izolacji.
              */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Sprawdzenie, czy dana pozycja już istnieje.
                SqlCommand commandCheckIfExists = new SqlCommand("SELECT Position_ID " +
                    "FROM Position WHERE Description = @Description", form.Connection, form.Transaction);
                commandCheckIfExists.Parameters.Add("@Description", SqlDbType.VarChar).Value = name;
                SqlDataReader reader = commandCheckIfExists.ExecuteReader();
                if (reader.Read())//Jeżeli dana pozycja już istnieje to rzuć wyjątek.
                {
                    reader.Close();
                    throw new EntryExistsException();
                }
                reader.Close();
                SqlCommand command = new SqlCommand("INSERT INTO Position " +
                    "VALUES((SELECT MAX(Position_ID) + 1 FROM Position), @Name)", form.Connection, form.Transaction);
                command.Parameters.Add("@Name", SqlDbType.VarChar).Value = name;
                command.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #11
0
        /// <summary>
        /// Metoda służąca do "dawania" pracownikowi dodatkowych dni urlopowych. Dodaje je najpierw do 
        /// normalnych dni urlopowych, a gdy ich liczba == liczba dni/rok, dodaje resztę dni do zaległych dni urlopowych.
        /// Możliwe jest odejmowanie dni urlopowych za pomocą tej metody. Aby to uczynić należy podać ujemną wartość do 
        /// argumentu number.
        /// </summary>
        /// <param name="form">Formularz wywołujący</param>
        /// <param name="employeeId">Numer id pracownika, któremu mają zostać dodane dni.</param>
        /// <param name="number">Liczba dodawanych dni. Może być ujemna.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentException">Występuje w przypadku próby odjęcia większej liczby dni, niż pracownik posiada.</exception>
        private static void AddLeaveDays(LeaveManagerForm form, int employeeId, int number)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
             * o odpowiednim poziomie izolacji.
             */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                /* Zmienne do których zczytane zostaną wartości odpowiednio liczby dni urlopowych,
                 * zaległych dni urlopowych oraz dni urlopowych przypadających na rok.
                 */
                int leaveDays = 0, oldLeaveDays = 0, yearDays = 0;
                /* Zczytanie aktualnych wartości do zmiennych dni. Dane te muszą być aktualne, aby
                 * nie było ryzyka, obliczamy i wpisujemy do bazy liczbę dni na podstawie danych
                 * nie aktualnych.
                 */
                GetDays(form, employeeId, ref leaveDays, ref oldLeaveDays, ref yearDays);
                //Polecenie sql aktualizujące liczbę dni danego pracownika.
                SqlCommand commandUpdateEmployee = new SqlCommand("UPDATE Employee SET " +
                    "Leave_days = @Leave_days, Old_leave_days = @Old_leave_days " +
                    "WHERE Employee_ID = @Employee_ID", form.Connection, form.Transaction);
                //Obliczenie wartości dla poszczególnych pól w bazie.
                //Jeżeli dodajemy dni.
                if (number > 0)
                {
                    //Jeżeli trzeba dodać dni zaległe.
                    if (leaveDays + number > yearDays)
                    {
                        commandUpdateEmployee.Parameters.Add("@Leave_days", SqlDbType.Int).Value = yearDays;
                        commandUpdateEmployee.Parameters.Add("@Old_leave_days", SqlDbType.Int).Value =
                            oldLeaveDays + number - (yearDays - leaveDays);
                    }
                    else
                    {
                        commandUpdateEmployee.Parameters.Add("@Leave_days", SqlDbType.Int).Value = leaveDays + number;
                        commandUpdateEmployee.Parameters.Add("@Old_leave_days", SqlDbType.Int).Value = 0;
                    }
                }
                else//Jeżeli odejmujemy dni.
                {
                    //Jeżeli odejmujemy więcej niż jest.
                    if (number + leaveDays + oldLeaveDays < 0)
                        throw new ArgumentException();
                    else
                    {
                        //Jeżeli liczba odejmowanych dni jest <= liczbie zaległych dni.
                        if (number + oldLeaveDays >= 0)
                        {
                            commandUpdateEmployee.Parameters.Add("@Leave_days", SqlDbType.Int).Value = leaveDays;
                            commandUpdateEmployee.Parameters.Add("@Old_leave_days", SqlDbType.Int).Value = number + oldLeaveDays;
                        }
                        else
                        {
                            commandUpdateEmployee.Parameters.Add("@Leave_days", SqlDbType.Int).Value = number + leaveDays + oldLeaveDays;
                            commandUpdateEmployee.Parameters.Add("@Old_leave_days", SqlDbType.Int).Value = 0;
                        }
                    }
                }
                commandUpdateEmployee.Parameters.Add("@Employee_ID", SqlDbType.Int).Value = employeeId;
                commandUpdateEmployee.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #12
0
        /// <summary>
        /// Metoda dodawania zgłoszenia urlopowego.
        /// </summary>
        /// <param name="form">Formularz potrzebujący metody.</param>
        /// <param name="leave">Obiekt reprezentujący nowy wpis urlopowy.</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentException">Występuje w przypadku próby odjęcia większej liczby dni, niż pracownik posiada.</exception>
        private static void AddLeave(LeaveManagerForm form, Leave leave)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
               * o odpowiednim poziomie izolacji.
               */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Liczba zużytych przez urlop dni.
                int usedDays;
                //Jeżeli urlop konsumuje dni.
                if (ConsumesDays(form, leave.LeaveType))
                {
                    usedDays = GetNumberOfWorkDays(form, leave.FirstDay, leave.LastDay, leave.EmployeeId);
                    //Odejmujemy pracownikowi dni za dany urlop.
                    AddLeaveDays(form, leave.EmployeeId, -usedDays);
                }
                else
                {
                    usedDays = 0;
                }
                //Polecenie sql Zczytujące największy nr id + 1
                SqlCommand commandGetNewId = new SqlCommand("(SELECT MAX(Leave_ID) + 1 FROM Leave)", form.Connection, form.Transaction);
                int newLeaveId;
                try
                {
                    newLeaveId = (int)commandGetNewId.ExecuteScalar();
                }
                catch
                {
                    //Jeżeli nie udało się zczytać id, to możliwe, że żaden wpis w bazie nie istnieje. Wtedy przypisujemy id = 0
                    newLeaveId = 0;
                }

                //Polecenie sql dodające nowy wpis urlopowy.
                SqlCommand commandInsertLeave = new SqlCommand("INSERT INTO Leave VALUES (@Leave_ID, @Employee_ID, " +
                     "(SELECT LT_ID FROM Leave_type WHERE Name = @Leave_type_name), (SELECT ST_ID FROM Status_type WHERE Name = @Status_name), " +
                     "@First_day, @Last_day, @Remarks, @Used_days)", form.Connection, form.Transaction);
                //Jeżeli wpis to chorobowe, to automatycznie otrzymuje stan zatwierdzony.
                if (leave.LeaveType.Equals("Sick"))
                {
                    commandInsertLeave.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = "Approved";
                }
                else
                {
                    //Jeżeli jest to urlop na żądanie, to automatycznie otrzymuje stan zatwierdzony.
                    if (leave.LeaveType.Equals("Extraordinary"))
                    {
                        commandInsertLeave.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = "Approved";
                        //Zaktualizowanie stanu liczby dostępnych dni na żądanie.
                        AddDemandDays(form, leave.EmployeeId, usedDays);
                    }
                    else
                    {
                        commandInsertLeave.Parameters.Add("@Status_name", SqlDbType.VarChar).Value = leave.LeaveStatus;
                    }
                }
                commandInsertLeave.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = newLeaveId;
                commandInsertLeave.Parameters.Add("@Employee_ID", SqlDbType.Int).Value = leave.EmployeeId;
                commandInsertLeave.Parameters.Add("@Leave_type_name", SqlDbType.VarChar).Value = leave.LeaveType;
                commandInsertLeave.Parameters.Add("@First_day", SqlDbType.Date).Value = leave.FirstDay;
                commandInsertLeave.Parameters.Add("@Last_day", SqlDbType.Date).Value = leave.LastDay;
                commandInsertLeave.Parameters.Add("@Remarks", SqlDbType.VarChar).Value = leave.Remarks;
                commandInsertLeave.Parameters.Add("@Used_days", SqlDbType.Int).Value = usedDays;
                commandInsertLeave.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #13
0
        /// <summary>
        /// Metoda dodawania nowego pracownika.
        /// </summary>
        /// <param name="form">Formularz wywołujący.</param>
        /// <param name="employee">Obiekt zawierający dane dodawanego pracownika.</param>
        /// <remarks>Jeżeli formularz ma uruchomioną transakcję,to poziom jej izolacji
        /// musi być == ReapeatableRead lub Serializable.
        /// 
        /// Nowy pracownik będzie posiadał losowo wygenerowane login i hasło składające się z cyfr.</remarks>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w 
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="NoFreeLoginException">Wyjątek występuje, gdy wszystkie z możliwych do wylosowania loginów są zajęte.</exception>
        private static void AddEmployee(LeaveManagerForm form, Employee employee)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
             * o odpowiednim poziomie izolacji.
             */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                //Obiekt umożliwiający losowanie.
                Random random = new Random();
                //Zmienna do której zostanie wygenerowany login.
                int login = 0;
                /* Zapytanie sql służące do sprawdzenia, czy wygenerowany login już istnieje. Jeżeli zwróci wynik,
                 * to oznacza to, że podany login istnieje.
                 */
                SqlCommand commandCheckLogin = new SqlCommand("SELECT Login FROM Employee WHERE Login = @Login",
                    form.Connection, form.Transaction);
                //Stworzenie obiektu służącego do czytania wyników zapytania.
                SqlDataReader reader;
                //Pętla szukająca wolnego loginu składającego się z 7 cyfr.
                for (int i = 1000000; i <= 10000000; ++i)
                {
                    //Wylosowanie loginu.
                    login = random.Next(1000000, 10000000);
                    //Wyczyszczenie parametrów zapytania.
                    commandCheckLogin.Parameters.Clear();
                    //Dodanei nowego parametru zapytania: losowo wygenerowanego loginu.
                    commandCheckLogin.Parameters.Add("@Login", SqlDbType.VarChar).Value = login.ToString();
                    //Przypisanie wyników zapytania z nowym parametrem do obiektu czytającego.
                    reader = commandCheckLogin.ExecuteReader();
                    /* Jeżeli obiekt czytający nie ma czego czytać (=> zapytanie nic nie zwróciło =>
                     * wygenerowany login nie istnieje w bazie.
                     */
                    if (!reader.Read())
                    {
                        //Zamykamy obiekt czytający i przerywamy pętle szukającą nie wykorzystanego loginu.
                        reader.Close();
                        reader.Dispose();
                        break;
                    }
                    reader.Close();
                    //Jeżeli szukanie wolnego loginu zakończyło się niepowodzeniem.
                    if (i == 10000000)
                        throw new NoFreeLoginException();
                }
                //Wygenerowanie 7 znakowego hasła składającego się z samych cyfr.
                int password = random.Next(1000000, 10000000);
                //Polecenie sql dodające wpis nowego pracownika. Nadaje mu id o 1 większe od największego numeru id w bazie.
                SqlCommand commandInsertEmployee = new SqlCommand("INSERT INTO Employee (Employee_ID, Permission_ID, Position_ID, " +
                  "Login, Password, Name, Surname, Birth_date, Address, PESEL, EMail, " +
                  "Year_leave_days, Leave_days, Old_leave_days) VALUES ((SELECT MAX(Employee_ID) + 1 FROM Employee)," +
                  "(SELECT Permission_ID FROM Permission WHERE Description = @Permission_Description), " +
                  "(SELECT Position_ID FROM Position WHERE Description = @Position_Description), " +
                  "@Login, @Password, @Name, @Surname, @Birth_date, @Address," +
                  "@PESEL, @EMail, @Year_leave_days, @Leave_days, 0)", form.Connection, form.Transaction);
                //Ustawienie parametrów polecenia.
                commandInsertEmployee.Parameters.Add("@Permission_Description", SqlDbType.VarChar).Value = employee.Permission;
                commandInsertEmployee.Parameters.Add("@Position_Description", SqlDbType.VarChar).Value = employee.Position;
                commandInsertEmployee.Parameters.Add("@Login", SqlDbType.VarChar).Value = login.ToString();
                commandInsertEmployee.Parameters.Add("@Password", SqlDbType.VarChar).Value = StringSha.GetSha256Managed(password.ToString());
                commandInsertEmployee.Parameters.Add("@Name", SqlDbType.VarChar).Value = employee.Name;
                commandInsertEmployee.Parameters.Add("@Surname", SqlDbType.VarChar).Value = employee.Surname;
                commandInsertEmployee.Parameters.Add("@Birth_date", SqlDbType.DateTime).Value = employee.BirthDate;
                commandInsertEmployee.Parameters.Add("@Address", SqlDbType.VarChar).Value = employee.Address;
                commandInsertEmployee.Parameters.Add("@PESEL", SqlDbType.VarChar).Value = employee.Pesel;
                commandInsertEmployee.Parameters.Add("@EMail", SqlDbType.VarChar).Value = employee.EMail;
                commandInsertEmployee.Parameters.Add("@Year_leave_days", SqlDbType.Int).Value = employee.YearLeaveDays;
                commandInsertEmployee.Parameters.Add("@Leave_days", SqlDbType.Int).Value = employee.LeaveDays;
                commandInsertEmployee.ExecuteNonQuery();
                /* Polecenie sql odpowiedzialne za wpisanie nowego pracownika do tablicy pracowników nie poinformowanych
                 * o swoim loginie i hasle.
                 */
                SqlCommand commandInsertUninformed = new SqlCommand("INSERT INTO Uninformed (Employee_ID, Password) " +
                    "VALUES ((SELECT MAX(Employee_ID) FROM Employee), @Password)", form.Connection, form.Transaction);
                commandInsertUninformed.Parameters.Add("@Password", SqlDbType.VarChar).Value = password.ToString();
                commandInsertUninformed.ExecuteNonQuery();
                /* Polecenie sql odpowiedzialne za dodanie pustego wpisu do tablicy z harmonogramem pracy*/
                SqlCommand commandInsertWorkHours = new SqlCommand("INSERT INTO Work_hours (Employee_ID) VALUES ((SELECT MAX(Employee_ID) FROM Employee))", form.Connection, form.Transaction);
                commandInsertWorkHours.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }
예제 #14
0
        /// <summary>
        /// Metoda dodawania/odejmowania dni zażądanych.
        /// </summary>
        /// <param name="form">Formularz potrzebujący metody.</param>
        /// <param name="employeeId">Numer id pracownika, któremu dodane/odjęte zostaną dni zażądane.</param>
        /// <param name="number">Liczba dni do dodania (ujemna, gdy chcemy odjąć).</param>
        /// <exception cref="SqlException">An exception occurred while executing the command against a locked row.</exception>
        /// <exception cref="InvalidOperationException">The current state of the connection is closed.</exception>
        /// <exception cref="IsolationLevelException">Wyjątek występuje, gdy poziom izolacji uruchomionej w
        /// formularzu transakcji jest zbyt niski do zapewnienia poprawnego wykonania poleceń metody.</exception>
        /// <exception cref="ArgumentException">Występuje w przypadku, gdy liczba dodawanych dni jest ujemna
        /// a wynikiem ich dodania byłaby liczba mniejsza od 0.</exception>
        /// <exception cref="OverflowException">Występuje w przypadku, gdy dodanie dni spowodowałoby przekroczenie
        /// wartości 4.</exception>
        private static void AddDemandDays(LeaveManagerForm form, int employeeId, int number)
        {
            /* Dla poprawnego działania tej metody konieczne jest aby posiadała ona transakcję
            * o odpowiednim poziomie izolacji.
            */

            //Zmienna przechowująca stan transakcji przed uruchomieniem metody.
            bool isFormTransactionOn = form.TransactionOn;
            //Jeżeli formularz posiada uruchomioną transakcję.
            if (form.TransactionOn)
            {
                //Sprawdzenie, czy poziom izolacji istniejącej transakcji jest wystarczający.
                if (form.Transaction.IsolationLevel != IsolationLevel.RepeatableRead &&
                    form.Transaction.IsolationLevel != IsolationLevel.Serializable)
                {
                    throw new IsolationLevelException();
                }
            }
            else//Jeżeli formularz nie posiada uruchomionej transakcji.
                //Uruchomienie nowej transakcji na potrzeby tej metody z odpowiednim poziomem izolacji.
                form.BeginTransaction(IsolationLevel.RepeatableRead);

            try
            {
                int demandedDays = GetDemadedDays(form, employeeId);

                if (demandedDays + number <= 4)
                {
                    if (demandedDays + number >= 0)
                    {
                        SqlCommand command = new SqlCommand("UPDATE Employee SET Demand_days = @Demand_days " +
                            "WHERE Employee_ID = @Employee_ID", form.Connection, form.Transaction);
                        command.Parameters.AddWithValue("@Demand_days", demandedDays + number);
                        command.Parameters.AddWithValue("@Employee_ID", employeeId);
                        command.ExecuteNonQuery();
                    }
                    else
                    {
                        throw new ArgumentException("Operation could not be performed because result would be lower than 0.");
                    }
                }
                else
                {
                    throw new OverflowException("Argument number + number of already demanded days is grater than 4.");
                }

            }
            catch (Exception e)
            {
                //Jeżeli transakcja formularza była uruchomiona tylko na potrzeby tej metody, to ją cofamy.
                if (!isFormTransactionOn)
                    form.RollbackTransaction();
                //Wyrzucamy wyjątek do dalszej obsługi.
                throw e;
            }
            //Jeżeli operacja powiodła się, a transakcja była uruchomiona tylko na potrzeby tej metody to ją zatwierdzamy.
            if (!isFormTransactionOn)
                form.CommitTransaction();
        }