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