/// <summary>
/// Konstruktor.
/// </summary>
/// <param name="leaveManagerParentForm">Obiekt rodzica.</param>
/// <param name="connection">Połączenie z bazą danych. Powinno być otwarte.</param>
/// <param name="employeeId">Numer id pracownika, którego dotyczy zgłoszenie urlopowe.</param>
/// <param name="firstDay">Data rozpoczęcia urlopu.</param>
/// <param name="lastDay">Data zakończenia urlopu.</param>
public FormLeaveConsideration(LeaveManagerForm leaveManagerParentForm, SqlConnection connection, Leave consideredLeave )
{
InitializeComponent();
this.connection = connection;
this.consideredLeave = consideredLeave;
this.leaveManagerParentForm = leaveManagerParentForm;
labelFirstDayValue.Text = consideredLeave.FirstDay.ToString("d");
labelLastDayValue.Text = consideredLeave.LastDay.ToString("d");
try
{
//Zczytanie imienia, nazwiska oraz pozycji pracownika.
Employee employee = this.GetEmployee(consideredLeave.EmployeeId);
labelNameValue.Text = employee.Name;
labelPositionValue.Text = employee.Position;
DateTime tmp = consideredLeave.FirstDay;
bool[] days = this.GetWorkingDaysOfWeek(employee.EmployeeId);
while (tmp <= consideredLeave.LastDay)
{
if (days[((int)tmp.DayOfWeek + 6) % 7] && !IsHoliday(tmp))
dataGridView.Rows.Add(tmp, this.GetSimiliarWorkerCount(this.GetPositionID(employee.Position), employee.EmployeeId, tmp), this.GetNeededEmployeesNo(tmp));
tmp = tmp.AddDays(1);
}
}
catch (SqlException)
{
MessageBox.Show("SQL Error. This form will be close. Please try again later.");
this.Close();
}
catch (InvalidOperationException)
{
MessageBox.Show("Invalid operation. This form will be close. Please try again later");
this.Close();
}
catch (EmployeeIdException)
{
MessageBox.Show("EmployeeID not found in database. This form will be close. Please try again later");
this.Close();
}
catch (Exception ex)
{
MessageBox.Show("Unknown exception has occured" + ex.Message);
this.Close();
}
}
/// <summary>
/// Zwraca tablicę pracowników będących obecnie na urlopie
/// </summary>
/// <param name="form">Formularz wywołujący</param>
/// <returns>Tabela z danymi pracowników będących na urlopie</returns>
/// <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>
private static DataTable GetEmployeesCurrentlyOnLeave(LeaveManagerForm form)
{
DataTable result = new DataTable();
using (SqlCommand command = new SqlCommand("SELECT E.Name, E.Surname, P.Description AS Position, L.First_day AS 'Start', " +
"L.Last_day AS 'End', LT.Name AS 'Leave type' FROM Employee AS E INNER JOIN " +
"Leave AS L ON E.Employee_ID = L.Employee_ID INNER JOIN Position AS P ON E.Position_ID = P.Position_ID " +
"INNER JOIN Leave_type AS LT ON L.LT_ID = LT.LT_ID WHERE (L.First_day <= @Date) AND (L.Last_day >= @Date)", form.Connection))
{
command.Parameters.AddWithValue("@Date", GetServerTimeNow(form).Date);
if (form.TransactionOn)
command.Transaction = form.Transaction;
SqlDataReader reader = command.ExecuteReader();
result.Load(reader);
}
return result;
}
/// <summary>
/// Zwraca opis podanej pozycji
/// </summary>
/// <param name="form">Formularz wywołujący</param>
/// <param name="positiondID">ID pozycji</param>
/// <returns>Opis pozycji</returns>
/// <exception cref="SqlException">"Sql Error"</exception>
public static string GetPositionDescription(LeaveManagerForm form, int positiondID)
{
using (SqlCommand command = new SqlCommand("SELECT Description FROM Position WHERE Position_ID = @Position", form.Connection))
{
if (form.TransactionOn)
command.Transaction = form.Transaction;
command.Parameters.AddWithValue("@Position", positiondID);
return (string)command.ExecuteScalar();
}
}
/// <summary>
/// Metoda służaca do wyszukiwania pracownika.
/// </summary>
/// <param name="form">Formularz wywołujący metodę</param>
/// <param name="name">Imię pracownika, który ma zostać wyszukany</param>
/// <param name="surname">Nazwisko pracownika, który ma zostać wyszukany</param>
/// <param name="pesel">Pesel pracownika, który ma zostać wyszukany</param>
/// <param name="position">Pozycja pracownika, który ma zostać wyszukany</param>
/// <returns>Tabele z danymi pracowników spełniających kryteria</returns>
/// <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>
private static DataTable SearchEmployee(LeaveManagerForm form, String name, String surname, String pesel, String position)
{
//Zapytanie sql zczytujące dane pracownika o podanym loginie i haśle.
SqlCommand command = new SqlCommand("SELECT E.Employee_ID AS 'Employee id', " +
"E.Name, E.Surname, E.Birth_date AS 'Birth date'," +
"E.Address, E.PESEL, E.EMail AS 'e-mail', Pos.Description AS 'Position', " +
"Perm.Description AS 'Permission', E.Leave_days AS 'Remaining leave days', " +
"E.Old_leave_days AS 'Old left leave days' " +
"FROM Employee E, Position Pos, Permission Perm " +
"WHERE E.Permission_ID = Perm.Permission_ID " +
"AND E.Position_ID = Pos.Position_ID AND Name LIKE @Name AND " +
"Surname LIKE @Surname AND PESEL LIKE @Pesel AND Pos.Description LIKE @Position", form.Connection);
//Dodanie parametru imienia.
name = "%" + name + "%";
command.Parameters.Add("@Name", SqlDbType.VarChar).Value = name;
//Dodanie parametru nazwiska.
surname = "%" + surname + "%";
command.Parameters.Add("@Surname", SqlDbType.VarChar).Value = surname;
//Dodania parametru peselu
pesel = "%" + pesel + "%";
command.Parameters.Add("@Pesel", SqlDbType.VarChar).Value = pesel;
//Dodanie parametru pozycji.
position = "%" + position + "%";
command.Parameters.Add("@Position", SqlDbType.VarChar).Value = position;
//Jeżeli formularz ma włączoną transakcję.
if (form.TransactionOn)
//Przypisanie do zapytania transakcji formularza.
command.Transaction = form.Transaction;
//Stworzenie obiektu wyniku.
DataTable result = new DataTable();
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Jeżeli wyniki zapytania są nie puste.
result.Load(reader);
//Zamknięcie obiektu czytającego.
reader.Close();
//Zwrócenie wyniku.
return result;
}
/// <summary>
/// Metoda powodująca przeliczenie liczby dni dla danego pracownika.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <param name="employeeId">Numer id pracownika.</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>
private static void RecountLeaveDays(LeaveManagerForm form, int employeeId)
{
int daysToAdd = 0;
DataTable leaves = GetLeaves(form, employeeId);
for (int i = 0; i < leaves.Rows.Count; ++i)
{
//Jeżeli urlop zaczyna się później niż teraz.
if ((GetServerTimeNow(form).CompareTo((DateTime)leaves.Rows[i].ItemArray.GetValue(2)) < 0)
//Jeżeli urlop konsumuje dni.
&& ConsumesDays(form, leaves.Rows[i].ItemArray.GetValue(4).ToString()))
{
int numberOfUsedDays = GetNumberOfWorkDays(form, (DateTime)leaves.Rows[i].ItemArray.GetValue(2),
(DateTime)leaves.Rows[i].ItemArray.GetValue(3), employeeId);
if ((int)leaves.Rows[i].ItemArray.GetValue(6) != numberOfUsedDays)
{
daysToAdd += ((int)leaves.Rows[i].ItemArray.GetValue(6)) - numberOfUsedDays;
using (SqlCommand command = new SqlCommand("UPDATE Leave SET Used_days = @Used_days WHERE Leave_ID = @Leave_ID", form.Connection, form.Transaction))
{
command.Parameters.AddWithValue("@Leave_ID", leaves.Rows[i].ItemArray.GetValue(0));
command.Parameters.AddWithValue("@Used_days", numberOfUsedDays);
command.ExecuteNonQuery();
}
}
}
}
AddLeaveDays(form, employeeId, daysToAdd);
}
/// <summary>
/// Metoda sprawdzająca, czy któryś z dni z okresu między argumentami date1 i date2
/// jest użyty w ktorymś aktywnym(nie odrzuconym/anulowanym) zgłoszeniu urlopowym
/// danego pracownika. Przy sprawdzaniu pomija wpis urlopowy zaczynający się w podanym
/// dniu.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <param name="date1">Data rozpoczęcia okresu.</param>
/// <param name="date2">Data zakończenia okresu.</param>
/// <param name="employeeID">Numer id pracownika, którego urlopy będą brane pod uwagę.</param>
/// <param name="skippedEntryFirstDay">Data rozpoczęcia ignorowanego wpisu urlopowego.</param>
/// <returns>Wartość logiczną mówiącą czy któryś z dni okresu jest już użyty.</returns>
/// <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>
private static bool IsDateFromPeriodUsed(LeaveManagerForm form, DateTime date1, DateTime date2,
int employeeID, DateTime skippedEntryFirstDay)
{
//Jeżeli date2 jest wcześniej niż date1 zamień je miejscami.
if (date1.CompareTo(date2) > 0)
{
DateTime tmpDate = date1;
date1 = date2;
date2 = tmpDate;
}
//Zapytanie sql zczytujące daty urlopów.
SqlCommand command = new SqlCommand("SELECT First_day, Last_day FROM Leave WHERE " +
"Employee_ID = @Employee_ID AND First_day != @Skipped_entry_first_day", form.Connection);//todo dodać warunek w zapytaniu wykluczający wpisy, canceled i rejected.
//Jeżeli formularz ma uruchomioną transakcję, dołącz ją do zapytania.
if (form.TransactionOn)
command.Transaction = form.Transaction;
command.Parameters.Add("@Employee_ID", SqlDbType.Int).Value = employeeID;
command.Parameters.Add("@Skipped_entry_first_day", SqlDbType.Date).Value = skippedEntryFirstDay;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Dopóki udało się odczytać wiersz z wyników zapytania.
while (reader.Read())
{
//Zczytanie dni początku i końca urlopu.
DateTime firstDay = (DateTime)reader["First_day"];
DateTime lastDay = (DateTime)reader["Last_day"];
if ((date1.CompareTo(firstDay) <= 0) && (date2.CompareTo(firstDay) >= 0)//firstDay between date1 & date2
|| (date1.CompareTo(lastDay) <= 0) && (date2.CompareTo(lastDay) >= 0)//lastDay between date1 & date2
|| (date1.CompareTo(firstDay) >= 0 && (date2.CompareTo(lastDay) <= 0)))//date1 & date2 between firstDay & lastDay
{
reader.Close();
return true;
}
}
//Jeżeli nie znaleziono kolizji.
reader.Close();
return false;
}
/// <summary>
/// Metoda pobierania tabeli zawierającej informacje o nowych pracownikach, którzy nie zostali jeszcze
/// poinformowanie o swoim loginie/haśle.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <returns>Zwraca tabelę zawierającą informacje o nowych pracownikach, którzy nie zostali jeszcze
/// poinformowani o swoim loginie/haśle. Kolumny tabeli:
/// "ID", "e-mail", "Login", "Password", "Name", "Surname"</returns>
/// <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>
private static DataTable GetUninformedEmployees(LeaveManagerForm form)
{
SqlCommand command = new SqlCommand("SELECT E.Employee_ID AS 'ID', E.EMail AS 'e-mail', E.Login, U.Password, E.Name, " +
"E.Surname FROM Employee E, Uninformed U WHERE E.Employee_ID = U.Employee_ID", form.Connection);
//Jeżeli formularz ma włączoną transakcję, to dołącz ją do zapytania.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Stworzenie tabeli na dane.
DataTable uninformedEmployees = new DataTable();
//Załadowanie danych do tabeli.
uninformedEmployees.Load(reader);
reader.Close();
return uninformedEmployees;
}
/// <summary>
/// Metoda oblicza liczbę pracowników danego typu, którzy są dostępni danego dnia.
/// </summary>
/// <param name="form">Formularz wywołujący metode</param>
/// <param name="positionId">Pozycja szukanych pracowników</param>
/// <param name="employeeId">"Identyfikator pracownika, który nie jest brany pod uwagę (np. ubiega się o
/// urlop w danym dniu)"</param>
/// <param name="date">"Data"</param>
/// <returns>"Liczba pracowników tego samego typu, którzy są dostępni danego dnia</returns>
/// <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="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>
private static int GetSimiliarWorkerCount(LeaveManagerForm form, int positionId, int employeeId, DateTime date)
{
string day = date.DayOfWeek.ToString();
//using (SqlCommand command = new SqlCommand("SELECT COUNT(DISTINCT E.Employee_ID) AS amount " +
// "FROM Employee AS E LEFT OUTER JOIN Leave AS L ON E.Employee_ID = L.Employee_ID " +
// "LEFT OUTER JOIN Work_hours AS W ON E.Employee_ID = W.Employee_ID " +
// "WHERE (E.Position_ID = @Position) AND (L.First_day > @Date) AND (W." + day + "Start <> W."
// + day + "End) AND (E.Employee_ID != @EmployeeID) OR " +
// "(E.Position_ID = @Position) AND (L.Last_day < @Date) AND (W." + day + "Start <> W."
// + day + "End) AND (E.Employee_ID != @EmployeeID) OR " +
// "(E.Position_ID = @Position) AND (L.Leave_ID IS NULL) AND (W." + day + "Start <> W."
// + day + "End) AND (E.Employee_ID != @EmployeeID) OR " +
// "(E.Position_ID = @Position) AND (L.LS_ID != (SELECT ST_ID From Status_type WHERE Name = 'Approved')) AND (W." + day + "Start <> W."
// + day + "End) AND (E.Employee_ID != @EmployeeID)", form.Connection))
//{
using (SqlCommand command = new SqlCommand("SELECT COUNT(E.Employee_ID) AS amount " +
"FROM Employee AS E LEFT OUTER JOIN Replacments AS R ON E.Employee_ID = R.Employee_ID "+
"WHERE (E.Employee_ID NOT IN " +
"(SELECT DISTINCT W.Employee_ID FROM Work_hours AS W LEFT OUTER JOIN " +
"Leave AS L ON L.Employee_ID = W.Employee_ID WHERE (L.First_day <= @Date) " +
"AND (L.Last_day >= @Date) AND (L.LS_ID = 3) OR (W." + day + "Start = W." + day + "End) OR " +
"(W.Employee_ID = @EmployeeID)) OR (R.Date = @Date)) AND (E.Position_ID = @Position)", form.Connection))
{
//"SELECT COUNT(E.Employee_ID) AS amount " +
// "FROM Employee AS E LEFT OUTER JOIN Replacments AS R ON E.Employee_ID = R.Employee_ID "+
// "WHERE (E.Employee_ID NOT IN " +
// "(SELECT DISTINCT W.Employee_ID FROM Work_hours AS W LEFT OUTER JOIN " +
// "Leave AS L ON L.Employee_ID = W.Employee_ID WHERE (L.First_day <= @Date) " +
// "AND (L.Last_day >= @Date) AND (L.LS_ID = 3) OR (W." + day + "Start = W." + day + "End)) OR (R.Date = @Date)) " +
// "AND (E.Position_ID = @Position)"
if (form.TransactionOn)
{
command.Transaction = form.Transaction;
}
command.Parameters.AddWithValue("@Position", positionId);
command.Parameters.AddWithValue("@Date", date);
command.Parameters.AddWithValue("@EmployeeID", employeeId);
using (SqlDataReader reader = command.ExecuteReader())
{
int result;
if (reader.Read())
result = (int)reader["amount"];
else
result = 0;
reader.Close();
return result;
}
}
}
/// <summary>
/// Zwraca liczbę pracowników którzy muszą być w pracy danego dnia.
/// </summary>
/// <param name="form">"Formularz wywołujący metode"</param>
/// <param name="date">"Data do sprawdzenia"</param>
/// <returns>"Liczba pracowników wymaganych w pracy"</returns>
/// <exception cref="SqlException">"Sql Error"</exception>
private static int GetNeededEmployeesNo(LeaveManagerForm form, DateTime date)
{
using (SqlCommand command = new SqlCommand("SELECT Workers_no FROM Workers_needed WHERE Day = @Day", form.Connection))
{
if (form.TransactionOn)
command.Transaction = form.Transaction;
command.Parameters.AddWithValue("@Day", date.DayOfWeek.ToString());
return (int)command.ExecuteScalar();
}
}
/// <summary>
/// Metoda pobierania z bazy danych typów urlopów do tabeli.
/// </summary>
/// <param name="form">Formularz z którego została wywołana metoda.</param>
/// <returns>Zwraca tabelę zawierającą informacje o typach urlopów posortowane po numerze id.
/// Zwracana tabela zawiera następujące kolumny:
/// "Leave type id", "Name", "Consumes days". </returns>
/// <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>
private static DataTable GetLeaveTypesTable(LeaveManagerForm form)
{
//Zapytanie sql zczytujące dane.
SqlCommand command = new SqlCommand("SELECT LT_ID AS 'Leave type id', Name, Consumes_days AS 'Consumes days' " +
"FROM Leave_type ORDER BY LT_ID", form.Connection);
//Jeżeli transakcja jest włączona, to ujmij nią również to zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Inicjalizacja obiektu wyniku.
DataTable result = new DataTable();
//Stworzenie obiektu czytającego wyniki polecenia.
SqlDataReader reader = command.ExecuteReader();
//Wypełnienie tabeli wynikiem zapytania sql.
result.Load(reader);
//Zamknięcie obiektu czytającego.
reader.Close();
return result;
}
/// <summary>
/// Metoda pobierania z bazy danych typów urlopów do listy.
/// </summary>
/// <param name="form">Formularz z którego została wywołana metoda.</param>
/// <returns>Zwraca listę typów urlopów.</returns>
/// <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>
private static List<LeaveType> GetLeaveTypesList(LeaveManagerForm form)
{
//Lista do której zostaną zczytane dane z bazy danych.
List<LeaveType> result = new List<LeaveType>();
//Zapytanie sql zczytujące typy urlopów.
SqlCommand command = new SqlCommand("SELECT LT_ID AS 'Leave type id', Name, Consumes_days AS 'Consumes days' " +
"FROM Leave_type ORDER BY LT_ID", form.Connection);
//Jeżeli formularz ma włączoną transakcję, to dodaj zapytanie do tej transakcji.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Wykonuj dopóki udało się odczytać kolejny wiersz.
while (reader.Read())
{
//Dodanie kolejnego wpisu do listy wyniku.
result.Add(new LeaveType((int)reader["Leave type id"], reader["Name"].ToString(), (bool)reader["Consumes days"]));
}
//Zamknięcie obiektu czytającego.
reader.Close();
return result;
}
/// <summary>
/// Metoda zwraca historię urlopów
/// </summary>
/// <param name="form">Formularz wywołujący</param>
/// <returns>Zwraca tabele z pobranymi urlopami</returns>
/// <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>
private static DataTable GetLeavesHistory(LeaveManagerForm form)
{
DataTable result = new DataTable();
using (SqlCommand command = new SqlCommand("SELECT E.Name, E.Surname, P.Description AS Position, L.First_day AS 'Start', L.Last_day AS 'End', LT.Name AS 'Leave type' " +
"FROM Employee AS E INNER JOIN Leave AS L ON E.Employee_ID = L.Employee_ID INNER JOIN " +
"Position AS P ON E.Position_ID = P.Position_ID INNER JOIN Leave_type AS LT ON L.LT_ID = LT.LT_ID", form.Connection))
{
if (form.TransactionOn)
command.Transaction = form.Transaction;
SqlDataReader reader = command.ExecuteReader();
result.Load(reader);
return result;
}
}
/// <summary>
/// Zwraca urlopy które kończą się po podanej dacie.
/// </summary>
/// <param name="form">"Formularz wywołujący"</param>
/// <param name="date">"Data od której interesują nas urlopy"</param>
/// <returns>"Tablica zawierająca informację o urlopach, które dopiero mają się rozpocząć</returns>
/// <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>
private static DataTable GetLeavesForFuture(LeaveManagerForm form)
{
DataTable result = new DataTable();
using (SqlCommand command = new SqlCommand("SELECT E.Position_ID, L.Leave_ID, L.First_day, L.Last_day " +
"FROM Employee AS E INNER JOIN Leave AS L ON E.Employee_ID = L.Employee_ID " +
"WHERE L.Last_day > @Date ORDER BY L.First_day", form.Connection))
{
if (form.TransactionOn)
command.Transaction = form.Transaction;
command.Parameters.AddWithValue("@Date", GetServerTimeNow(form).Date);
SqlDataReader reader = command.ExecuteReader();
result.Load(reader);
}
return result;
}
/// <summary>
/// Metoda pobietania tabeli z danymi urlopowymi danego pracownika.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <param name="employeeId">Numer id pracownika.</param>
/// <returns>Zwraca tabelę z danymi urlopowymi pracownika.
/// Kolumny tabeli: "Leave Id", "Status", "First day", "Last day", "Type",
/// "Remarks", "No. used days"</returns>
/// <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>
private static DataTable GetLeaves(LeaveManagerForm form, int employeeId)
{
//Zapytanie zczytujące dane.
SqlCommand commandSelectLeaves = new SqlCommand("SELECT Leave_ID AS 'Leave Id', LS.Name AS 'Status', L.First_day AS 'First day', " +
"L.Last_day AS 'Last day', LT.Name AS 'Type', L.Remarks, L.Used_days AS 'No. used days' " +
"FROM Employee E, Leave L, Leave_type LT, Status_type LS " +
"WHERE L.LT_ID = LT.LT_ID AND L.LS_ID = LS.ST_ID AND E.Employee_ID = L.Employee_ID " +
"AND E.Employee_ID = @Employee_ID ORDER BY L.First_day", form.Connection);
//Jeżeli formularz ma uruchomioną transakcję, dodaj ją do zapytania.
if (form.TransactionOn)
commandSelectLeaves.Transaction = form.Transaction;
commandSelectLeaves.Parameters.Add("@Employee_ID", SqlDbType.Int).Value = employeeId;
//Stwórz obiekt czytający wyniki zapytania.
SqlDataReader readerLeaves = commandSelectLeaves.ExecuteReader();
//Stworzenie obiektu do którego załadowane zostaną dane.
DataTable leaves = new DataTable();
//Wczytanie danych.
leaves.Load(readerLeaves);
return leaves;
}
/// <summary>
/// Metoda pobierająca wpis urlopowy.
/// </summary>
/// <param name="form">Formularz potrzebujący metody.</param>
/// <param name="id">Numer id pobieranego urlopu.</param>
/// <returns>Obiekt reprezentujący dany urlop.</returns>
/// <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>
private static Leave GetLeave(LeaveManagerForm form, int leaveId)
{
SqlCommand command = new SqlCommand("SELECT L.Employee_ID, LT.Name AS 'Type', " +
"LS.Name AS 'Status', L.First_day, L.Last_day, " +
"L.Remarks, L.Used_days FROM Leave L, Leave_type LT, Status_type LS WHERE Leave_ID = @Leave_ID",
form.Connection);
if (form.TransactionOn)
command.Transaction = form.Transaction;
command.Parameters.Add("@Leave_ID", SqlDbType.Int).Value = leaveId;
SqlDataReader reader = command.ExecuteReader();
reader.Read();
Leave result = new Leave(leaveId, (int)reader["Employee_ID"], reader["Type"].ToString(), reader["Status"].ToString(),
(DateTime)reader["First_day"], (DateTime)reader["Last_day"], reader["Remarks"].ToString(), (int)reader["Used_days"]);
reader.Close();
return result;
}
/// <summary>
/// Metoda pobierania harmonogramu pracy.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <param name="employeeId">Numer id pracownika.</param>
/// <returns>Tablicę z harmonogramem pracy.</returns>
/// <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>
private static DataTable GetSchedule(LeaveManagerForm form, int employeeId)
{
using (SqlCommand command = new SqlCommand("SELECT MondayStart, MondayEnd, TuesdayStart, TuesdayEnd" +
", WednesdayStart, WednesdayEnd, ThursdayStart, ThursdayEnd, FridayStart, FridayEnd" +
", SaturdayStart, SaturdayEnd, SundayStart, SundayEnd FROM Work_hours WHERE Employee_ID = @Employee_ID",
form.Connection))
{
if (form.TransactionOn)
{
command.Transaction = form.Transaction;
}
command.Parameters.AddWithValue("@Employee_ID", employeeId);
using (SqlDataReader reader = command.ExecuteReader())
{
DataTable result = new DataTable();
result.Load(reader);
return result;
}
}
}
/// <summary>
/// Metoda pobierająca aktualny czas serwera.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <returns>Aktualny czas serwera.</returns>
private static DateTime GetServerTimeNow(LeaveManagerForm form)
{
SqlCommand commandGetServerTime = new SqlCommand("SELECT GETDATE()", form.Connection);
if (form.TransactionOn)
commandGetServerTime.Transaction = form.Transaction;
return (DateTime)commandGetServerTime.ExecuteScalar();
}
/// <summary>
/// Metoda pobierająca tabelę ze zgłoszeniami urlopowymi (i ich właścicielami) wymagającymi zatwierdzenia/odrzucenia
/// różnego typu w zależności od tego, przej jaki typ formularza została wywołana.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <returns>Zwraca tabelę zawierającą zgłoszenia urlopowe wymagające zatwierdzenia/odrzucenia.
/// Tabela zawiera kolumny: "Employee id", "Position", "Name", "Surname", "e-mail", "Leave Id",
/// "Type", "Status"
/// "First day", "Last day", "Remarks", "Used days".</returns>
/// <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="ArgumentException">Rzucany, gdy formularz nie jest typu, który pozwala na tą operację.</exception>
private static DataTable GetNeedsAction(LeaveManagerForm form)
{
//Zapytanie sql zczytujące zgłoszenia wymagające zatwierdzenia/odrzucenia.
SqlCommand command = new SqlCommand("SELECT E.Employee_ID AS 'Employee id', P.Description AS 'Position', " +
"E.Name, E.Surname, E.EMail AS 'e-mail',L.Leave_ID AS 'Leave Id', LT.Name AS 'Type', " +
"LS.Name AS 'Status', L.First_day AS 'First day', L.Last_day AS 'Last day', L.Remarks, L.Used_days " +
"AS 'Used days' FROM Employee E, " +
"Leave L, Leave_type LT, Position P, Status_type LS WHERE L.Employee_ID = E.Employee_ID " +
"AND L.LT_ID = LT.LT_ID AND P.Position_ID = E.Position_ID AND LS.ST_ID = L.LS_ID AND " +
"LS.Name = @Name ORDER BY L.First_day", form.Connection);
//Jeżeli formularz posiada uruchomioną transakcję, to dodaj do niej zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Ustaw parametr nazwy statusu w zależności od typu formularza.
if (form.GetType() == new FormAssistant().GetType())
{
command.Parameters.Add("@Name", SqlDbType.VarChar).Value = "Pending validation";
}
else//to znaczy, że manager //todo ładny koment :P
{
if (form.GetType() == new FormManager().GetType())
{
command.Parameters.Add("@Name", SqlDbType.VarChar).Value = "Pending manager aproval";
}
else
{
throw new ArgumentException();
}
}
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
DataTable Result = new DataTable();
//Zczytanie wyników zapytania do tabeli.
Result.Load(reader);
reader.Close();
return Result;
}
/// <summary>
/// Metoda pobierająca listę możliwych stanów zgłoszenia urlopowego.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <returns>Lista możliwych stanów zgłoszenia (same nazwy).</returns>
/// <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>
private static List<String> GetStatusTypes(LeaveManagerForm form)
{
//Lista do której zostaną zczytane możliwe stany zgłoszeń urlopowych.
List<String> result = new List<string>();
//Zapytanie sql zczytujące możliwe stany zgłoszeń urlopowych.
SqlCommand command = new SqlCommand("SELECT Name FROM Status_type ORDER BY ST_ID", form.Connection);
//Jeżeli formularz posiada rozpoczętą transakcję, to dodaj do niej zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Dopóki udało się odczytać kolejną linijkę wyników zapytania.
while (reader.Read())
{
result.Add(reader["Name"].ToString());
}
reader.Close();
return result;
}
//todo tabela z dniami wolnymi od pracy, uwzględnić godziny/dni pracy pracownika, gdy już będa.
//Nie zapomnieć dodać odpowiednich wyjątków, gdy będzie operacja na BD.
/// <summary>
/// Metoda zwracająca liczbę dni w okresie od date1(włącznie) do date2(włącznie), które konsumują dni urlopowe.
/// </summary>
/// <param name="form">Formularz wymagający metody.</param>
/// <param name="date1">Pierwszy dzień sprawdzanego okresu.</param>
/// <param name="date2">Ostatni dzień sprawdzanego okresu.</param>
/// <returns>Liczba dni w okresie między date1 i date2, które konsumują dni rulopowe.</returns>
private static int GetNumberOfWorkDays(LeaveManagerForm form, DateTime date1, DateTime date2, int employeeId)
{
bool[] workingDays = GetWorkingDaysOfWeek(form, employeeId);
//Obliczenie różnicy czasu pomiędzy datami.
TimeSpan timeSpan = date2 - date1;
//Obliczenie maksymalnej liczby dni, które mogą konsumować dni.
int numberOfDays = (int)Math.Round(timeSpan.TotalDays) + 1;
//Dopóki nie sprawdzono wszystkich dni.
List<DateTime> publicHolidays = GetPublicHolidays(form);
while (date1.CompareTo(date2) <= 0)
{
switch (date1.DayOfWeek)
{
case DayOfWeek.Monday:
if (!workingDays[0])
{
numberOfDays--;
}
break;
case DayOfWeek.Tuesday:
if (!workingDays[1])
{
numberOfDays--;
}
break;
case DayOfWeek.Wednesday:
if (!workingDays[2])
{
numberOfDays--;
}
break;
case DayOfWeek.Thursday:
if (!workingDays[3])
{
numberOfDays--;
}
break;
case DayOfWeek.Friday:
if (!workingDays[4])
{
numberOfDays--;
}
break;
case DayOfWeek.Saturday:
if (!workingDays[5])
{
numberOfDays--;
}
break;
case DayOfWeek.Sunday:
if (!workingDays[6])
{
numberOfDays--;
}
break;
}
if (publicHolidays.IndexOf(date1) != -1)
{
numberOfDays--;
}
//Przesunięcie sprawdzanego dnia na następny.
date1 = date1.AddDays(1);
}
return numberOfDays;
}
private static bool[] GetWorkingDaysOfWeek(LeaveManagerForm form, int employeeId)
{
bool[] days = new bool[7];
DataTable schedule = GetSchedule(form, employeeId);
for (int i = 0; i < 7; ++i)
{
if (!schedule.Rows[0].ItemArray.GetValue(2 * i).ToString().Equals(schedule.Rows[0].ItemArray.GetValue((2 * i) + 1).ToString()))
{
days[i] = true;
}
else
{
days[i] = false;
}
}
return days;
}
/// <summary>
/// Metoda pobrania listy uprawnień.
/// </summary>
/// <param name="form">Formularz z którego została wywołana metoda.</param>
/// <returns>Zwraca listę ciągów znaków reprezentujących poziomy uprawnień.</returns>
/// <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>
private static List<String> GetPermissions(LeaveManagerForm form)
{
//Lista do której będą zczytywane rodzaje uprawnień.
List<String> result = new List<String>();
//Zapytanie sql zczytujące rodzaje uprawnień.
SqlCommand command = new SqlCommand("SELECT Description FROM Permission ORDER BY Permission_ID", form.Connection);
//Jeżeli formularz posiada uruchomioną transakcję, to ustaw ją jako transakcję polecenia sql.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Dopóki udało się odczytać kolejny wiersz wyników zapytania.
while (reader.Read())
{
//Dodanie nowego obiektu do listy.
result.Add(reader["Description"].ToString());
}
reader.Close();
return result;
}
/// <summary>
/// Metoda logowania.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <param name="login">Login.</param>
/// <param name="password">Hasło.</param>
/// <returns>Zwraca obiekt reprezentujący zalogowanego pracownika.</returns>
/// <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="LoginOrPasswordException">Login or password is wrong.</exception>
private static Employee Login(LeaveManagerForm form, String login, String password)
{
//Zapytanie sql zczytujące dane pracownika o podanym loginie i haśle.
SqlCommand command = new SqlCommand("SELECT E.Employee_ID, Perm.Description AS Permission, E.Name, E.Surname, E.Birth_date," +
"E.Address, E.PESEL, E.EMail, Pos.Description AS Position, E.Year_leave_days, " +
"E.Leave_days, E.Old_leave_days, E.Demand_days " +
"FROM Employee E, Permission Perm, Position Pos WHERE Login = @Login AND " +
"Password = @Password AND E.Permission_ID = Perm.Permission_ID AND " +
"E.Position_ID = Pos.Position_ID", form.Connection);
//Dodanie parametru loginu.
command.Parameters.Add("@Login", SqlDbType.VarChar).Value = login;
//Dodanie parametru hasła. Hasła są przechowywane w bazie w formie skrótu, stąd parametr to skrót hasła.
command.Parameters.Add("@Password", SqlDbType.VarChar).Value = StringSha.GetSha256Managed(password);
//Jeżeli formularz ma włączoną transakcję.
if (form.TransactionOn)
//Przypisanie do zapytania transakcji formularza.
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Jeżeli wyniki zapytania są nie puste.
if (reader.Read())
{
//Stworzenie nowego obiektu pracownika z danymi zczytanymi za pomocą zapytania.
Employee employee = new Employee((int)reader["Employee_ID"], reader["Permission"].ToString(),
reader["Name"].ToString(), reader["Surname"].ToString(), (DateTime)reader["Birth_date"],
reader["Address"].ToString(), reader["PESEL"].ToString(), reader["EMail"].ToString(),
reader["Position"].ToString(), (int)reader["Year_leave_days"], (int)reader["Leave_days"],
(int)reader["Old_leave_days"], (int)reader["Demand_days"]);
//Zamknięcie obiektu czytającego.
reader.Close();
//Zwrócenie wyniku.
return employee;
}
else//Nie znaleziono żadnego pracownika o podanym loginie i hasle.
{
//Zamknięcie obiektu czytającego.
reader.Close();
throw new LoginOrPasswordException();
}
}
/// <summary>
/// Metoda zwraca identyfikator pozycji o podanym opisie
/// </summary>
/// <param name="form">Formularz wywołujący</param>
/// <param name="position">Opis pozycji</param>
/// <returns>"Identyfikator pozycji o zadanym opisie"</returns>
/// <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="PositionException">"Bład podczas odczytywania pozycji (pozycja nie została odnaleziona"</exception>
private static int GetPositionID(LeaveManagerForm form, string position)
{
SqlCommand command = new SqlCommand("SELECT Position_ID FROM Position WHERE Description" +
" = @Description", form.Connection);
command.Parameters.Add("@Description", SqlDbType.VarChar).Value = position;
if (form.TransactionOn)
//Przypisanie do zapytania transakcji formularza.
command.Transaction = form.Transaction;
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
int result = (int)reader["Position_ID"];
reader.Close();
return result;
}
reader.Close();
throw new PositionException();
}
/// <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 pobierająca listę możliwych pozycji pracowników.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <returns>Zwraca listę możliwych pozycji pracowników..</returns>
/// <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>
private static List<String> GetPositionsList(LeaveManagerForm form)
{
//Stworzenie obiektu do którego będą zczytywane wyniki zapytania.
List<String> result = new List<string>();
//Zapytanie sql zczytujące nazwy pozycji.
SqlCommand command = new SqlCommand("SELECT Description FROM Position ORDER BY Position_ID", form.Connection);
//Jeżeli formularz ma rozpoczętą transakcję, to dodaj do niej zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Dopóki udało się odczytać kolejną linijkę wyników zapytania.
while (reader.Read())
{
//Dodanie nowego obiektu do listy wyników.
result.Add(reader["Description"].ToString());
}
reader.Close();
return result;
}
/// <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 pobrania tabeli z danymi pozycji.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <returns>Zwraca tabelę z danymi pozycji posortowane po numerach id pozycji.
/// Kolumny w zwracanej tabeli: "Position id", "Name".</returns>
/// <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>
private static DataTable GetPositionsTable(LeaveManagerForm form)
{
SqlCommand command = new SqlCommand("SELECT Position_ID AS 'Position id', " +
"Description AS 'Name' FROM Position ORDER BY Position_ID", form.Connection);
//Jeżeli formularz ma włączoną transakcję, to dołącz do niej zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu wyników.
DataTable result = new DataTable();
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
//Zczytanie wyników zapytania do tabeli.
result.Load(reader);
reader.Close();
return result;
}
/// <summary>
/// Gets public Holidays data.
/// </summary>
/// <param name="form">Formularz wywołujący metodę.</param>
/// <returns>Zwraca listę dat.</returns>
/// <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>
private static List<DateTime> GetPublicHolidays(LeaveManagerForm form)
{
using (SqlCommand command = new SqlCommand("SELECT Date FROM Public_holidays", form.Connection))
{
if (form.TransactionOn)
{
command.Transaction = form.Transaction;
}
using (SqlDataReader reader = command.ExecuteReader())
{
List<DateTime> results = new List<DateTime>();
while (reader.Read())
{
results.Add((DateTime)reader["Date"]);
}
return results;
}
}
}
/// <summary>
/// Metoda pobrania tabeli z danymi pracowników.
/// </summary>
/// <param name="form">Formularz wywołujący.</param>
/// <returns>Tabelę z danymi pracowników. Zawiera następujące kolumny:
/// "Employee id", "Name", "Surname", "Birth date", "Address",
/// "PESEL", "e-mail", "Position", "Permission", "Remaining leave days",
/// "Old leave days", "Demand days".</returns>
/// <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>
private static DataTable GetEmployees(LeaveManagerForm form)
{
//Zapytanie sql zwracające dane wszystkich pracowników.
SqlCommand command = new SqlCommand("SELECT E.Employee_ID AS 'Employee id', " +
"E.Name, E.Surname, E.Birth_date AS 'Birth date'," +
"E.Address, E.PESEL, E.EMail AS 'e-mail', Pos.Description AS 'Position', " +
"Perm.Description AS 'Permission', E.Leave_days AS 'Remaining leave days', " +
"E.Old_leave_days AS 'Old left leave days', Demand_days AS 'Demand days' " +
"FROM Employee E, Position Pos, Permission Perm " +
"WHERE E.Permission_ID = Perm.Permission_ID " +
"AND E.Position_ID = Pos.Position_ID", form.Connection);
//Jeżeli formularz ma włączoną transakcję, dołącz do niej zapytanie.
if (form.TransactionOn)
command.Transaction = form.Transaction;
//Stworzenie obiektu czytającego wyniki zapytania.
SqlDataReader reader = command.ExecuteReader();
DataTable Results = new DataTable();
//Załadowanie wyników zapytania do tabeli.
Results.Load(reader);
reader.Close();
return Results;
}