/// <summary>
/// Eduardo Colon
/// Created: 2019/03/10
///
/// //method to Deactivate shuttleReservation
/// </summary>
private void BtnDeactivateShuttleReservation_Click(object sender, RoutedEventArgs e)
{
if (dgShuttleReservation.SelectedItem != null)
{
ShuttleReservation current = (ShuttleReservation)dgShuttleReservation.SelectedItem;
try
{
if (current.Active == true)
{
var result = MessageBox.Show("Are you sure that you want to cancel this shuttle reservation?", "cancel ShuttleReservation", MessageBoxButton.YesNo);
if (result == MessageBoxResult.Yes)
{
_shuttleReservationManager.DeactivateShuttleReservation(current.ShuttleReservationID, current.Active);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
else
{
MessageBox.Show("You must select an item first");
}
refreshShuttleReservation();
}
private void setShuttleReservation(ShuttleReservation oldShuttleReservation, ShuttleReservation newShuttleReservation)
{
newShuttleReservation.ShuttleReservationID = oldShuttleReservation.ShuttleReservationID;
newShuttleReservation.GuestID = oldShuttleReservation.GuestID;
newShuttleReservation.EmployeeID = oldShuttleReservation.EmployeeID;
newShuttleReservation.PickupLocation = oldShuttleReservation.PickupLocation;
newShuttleReservation.DropoffDestination = oldShuttleReservation.DropoffDestination;
newShuttleReservation.PickupDateTime = oldShuttleReservation.PickupDateTime;
newShuttleReservation.DropoffDateTime = oldShuttleReservation.DropoffDateTime;
newShuttleReservation.Active = oldShuttleReservation.Active;
}
public void TestCreateShuttleReservationIDValidPickupTimw()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation()
{
ShuttleReservationID = 100000, GuestID = -1, EmployeeID = 100000, PickupLocation = "1840 Las Vegas Blvd", DropoffDestination = "1940 Broadway street", PickupDateTime = new DateTime(2008, 11, 12), DropoffDateTime = new DateTime(2008, 11, 12)
};
//Act
_shuttleReservationManager.CreateShuttleReservation(newShuttleReservation);
}
public void TestCreateShuttleReservationIDEmptyDropofflocation()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation()
{
ShuttleReservationID = 100000, GuestID = 100000, EmployeeID = 100000, PickupLocation = "1840 Las Vegas Blvd", DropoffDestination = "", PickupDateTime = new DateTime(2008, 11, 11), DropoffDateTime = new DateTime(2008, 11, 12)
};
//Act
_shuttleReservationManager.CreateShuttleReservation(newShuttleReservation);
}
public void TestCreatePickupLocationInValidInputEmpty()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation()
{
ShuttleReservationID = 100000, GuestID = 100000, EmployeeID = 100000, PickupLocation = "", DropoffDestination = "840 Broadway Street", PickupDateTime = new DateTime(2008, 11, 11), DropoffDateTime = new DateTime(2008, 11, 12)
};
//Act
_shuttleReservationManager.CreateShuttleReservation(newShuttleReservation);
}
public ShuttleReservation RetrieveShuttleReservationByShuttleReservationID(int shuttleReservationID)
{
ShuttleReservation shuttleReservation = new ShuttleReservation();
shuttleReservation = _shuttleReservation.Find(b => b.ShuttleReservationID == shuttleReservationID);
if (shuttleReservation.Equals(shuttleReservation))
{
throw new ArgumentException("ShuttleReservationID doesn't match.");
}
return(shuttleReservation);
}
/// <summary author="Eduardo Colon" created="2019/03/20">
/// method to check validation for all users inputs methods
/// </summary>
public bool isValid(ShuttleReservation shuttleReservation)
{
if (validatePickupLocation(shuttleReservation.PickupLocation) && validateDropoffDestination(shuttleReservation.DropoffDestination) &&
validatePickupDateTime(shuttleReservation.PickupDateTime)
)
//&& ValidatePickupDate(shuttleReservation.PickupDate
{
return(true);
}
return(false);
}
/// <summary author="Eduardo Colon" created="2019/03/20">
/// method to update shuttle reservation dropoff
/// </summary>
public void UpdateShuttleReservationDropoff(ShuttleReservation oldShuttleReservation)
{
try
{
_shuttleReservationAccessor.UpdateShuttleReservationDropoff(oldShuttleReservation);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
}
public void TestUpdateShuttleReservationInDropoffDestinationWithInputTooLong()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation();
setShuttleReservation(_shuttleReservations[0], newShuttleReservation);
string newDropoffDestination = createStringLength(1001);
newShuttleReservation.DropoffDestination = newDropoffDestination;
//Act
_shuttleReservationManager.UpdateShuttleReservation(_shuttleReservations[0], newShuttleReservation);
//Assert
_shuttleReservations = _shuttleReservationManager.RetrieveAllShuttleReservations();
Assert.AreEqual(_shuttleReservationManager.RetrieveShutteReservationByShuttleReservationID(_shuttleReservations[0].ShuttleReservationID).DropoffDestination, newShuttleReservation.DropoffDestination);
}
public void TestUpdateShuttleReservationInDropoffDateWithValidInput()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation();
setShuttleReservation(_shuttleReservations[0], newShuttleReservation);
DateTime newPickupDate = new DateTime(0, 0, 0);
newShuttleReservation.PickupDateTime = newPickupDate;
//Act
_shuttleReservationManager.UpdateShuttleReservation(_shuttleReservations[0], newShuttleReservation);
//Assert
_shuttleReservations = _shuttleReservationManager.RetrieveAllShuttleReservations();
Assert.AreEqual(_shuttleReservationManager.RetrieveShutteReservationByShuttleReservationID(_shuttleReservations[0].ShuttleReservationID).PickupDateTime, newShuttleReservation.PickupDateTime);
}
public void TestUpdateShuttleReservationInPickupLocationWithInputTooSmall()
{
//Arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation();
setShuttleReservation(_shuttleReservations[0], newShuttleReservation);
string newPickupLocation = createStringLength(0);
newShuttleReservation.PickupLocation = newPickupLocation;
//Act
_shuttleReservationManager.UpdateShuttleReservation(_shuttleReservations[0], newShuttleReservation);
//Assert
_shuttleReservations = _shuttleReservationManager.RetrieveAllShuttleReservations();
Assert.AreEqual(_shuttleReservationManager.RetrieveShutteReservationByShuttleReservationID(_shuttleReservations[0].ShuttleReservationID).PickupLocation, newShuttleReservation.PickupLocation);
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// //method to open the update dialog
/// </summary>
private void BtnUpdateShuttleReservation_Click(object sender, RoutedEventArgs e)
{
if (dgShuttleReservation.SelectedItem != null)
{
_shuttleReservation = (ShuttleReservation)dgShuttleReservation.SelectedItem;
var assign = new ShuttleReservationDetail(_shuttleReservation);
assign.ShowDialog();
}
else
{
MessageBox.Show("You must select an item first");
}
refreshShuttleReservation();
}
public void UpdateShuttleReservationDropoff(ShuttleReservation oldShuttleReservation)
{
foreach (var shuttleReservation in _shuttleReservation)
{
if (shuttleReservation.ShuttleReservationID == oldShuttleReservation.ShuttleReservationID)
{
shuttleReservation.ShuttleReservationID = oldShuttleReservation.ShuttleReservationID;
shuttleReservation.GuestID = oldShuttleReservation.GuestID;
shuttleReservation.EmployeeID = oldShuttleReservation.EmployeeID;
shuttleReservation.PickupLocation = oldShuttleReservation.PickupLocation;
shuttleReservation.DropoffDestination = oldShuttleReservation.DropoffDestination;
shuttleReservation.PickupDateTime = oldShuttleReservation.PickupDateTime;
// shuttleReservation.DropoffDateTime = newShuttleReservation.DropoffDateTime;
}
}
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to update shttlereservation
/// </summary>
public void UpdateShuttleReservationDropoff(ShuttleReservation oldShuttleReservation)
{
// get a connection
var conn = DBConnection.GetDbConnection();
// command text
string cmdText = "sp_shuttle_dropoff_time_now";
// command object
var cmd = new SqlCommand(cmdText, conn);
// command type
cmd.CommandType = CommandType.StoredProcedure;
// parameters
cmd.Parameters.AddWithValue("@ShuttleReservationID", oldShuttleReservation.ShuttleReservationID);
cmd.Parameters.AddWithValue("@OldGuestID", oldShuttleReservation.GuestID);
cmd.Parameters.AddWithValue("@OldEmployeeID", oldShuttleReservation.EmployeeID);
cmd.Parameters.AddWithValue("@OldPickupLocation", oldShuttleReservation.PickupLocation);
cmd.Parameters.AddWithValue("@OldDropoffDestination", oldShuttleReservation.DropoffDestination);
cmd.Parameters.AddWithValue("@OldPickupDateTime", oldShuttleReservation.PickupDateTime);
try
{
// open the connection
conn.Open();
cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to retrieve all inactive shuttle reservations
/// </summary>
public List <ShuttleReservation> RetrieveInactiveShuttleReservations()
{
List <ShuttleReservation> shuttleReservations = new List <ShuttleReservation>();
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_retrieve_inactive_shuttle_reservation";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
try
{
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
ShuttleReservation shuttleReservation = new ShuttleReservation();
shuttleReservation.ShuttleReservationID = reader.GetInt32(0);
shuttleReservation.GuestID = reader.GetInt32(1);
shuttleReservation.EmployeeID = reader.GetInt32(2);
shuttleReservation.PickupLocation = reader.GetString(3);
shuttleReservation.DropoffDestination = reader.GetString(4);
shuttleReservation.PickupDateTime = reader.GetDateTime(5);
shuttleReservation.DropoffDateTime = reader.GetDateTime(6);
shuttleReservation.Active = reader.GetBoolean(7);
shuttleReservations.Add(shuttleReservation);
}
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(shuttleReservations);
}
/// <summary author="Eduardo Colon" created="2019/03/20">
/// method to create shuttle reservation
/// </summary>
public int CreateShuttleReservation(ShuttleReservation newShuttleReservation)
{
int result = 0;
try
{
if (!isValid(newShuttleReservation))
{
throw new ArgumentException("The data for this shuttle reservation is invalid");
}
result = _shuttleReservationAccessor.InsertShuttleReservation(newShuttleReservation);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
return(result);
}
public void TestCreateShuttleReservationWithAllValidInputs()
{
//arrange
ShuttleReservation newShuttleReservation = new ShuttleReservation()
{
ShuttleReservationID = 100000, GuestID = 100000, EmployeeID = 100000, PickupLocation = "1840 Las Vegas Blvd", DropoffDestination = "840 Broadway Street", PickupDateTime = new DateTime(2008, 11, 11), DropoffDateTime = new DateTime(2008, 11, 12)
};
//Act
_shuttleReservationManager.CreateShuttleReservation(newShuttleReservation);
//Assert
_shuttleReservations = _shuttleReservationManager.RetrieveAllShuttleReservations();
Assert.IsNotNull(_shuttleReservations.Find(s => s.ShuttleReservationID == newShuttleReservation.ShuttleReservationID &&
s.GuestID == newShuttleReservation.GuestID && s.EmployeeID == newShuttleReservation.EmployeeID &&
s.PickupLocation == newShuttleReservation.PickupLocation && s.DropoffDestination == newShuttleReservation.DropoffDestination &&
s.PickupDateTime == newShuttleReservation.PickupDateTime && s.DropoffDateTime == newShuttleReservation.DropoffDateTime
));
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to insert shuttlereservation
/// </summary>
public int InsertShuttleReservation(ShuttleReservation newShuttleReservation)
{
int result = 0;
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_insert_shuttle_reservation";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@GuestID", newShuttleReservation.GuestID);
cmd.Parameters.AddWithValue("@EmployeeID", newShuttleReservation.EmployeeID);
cmd.Parameters.AddWithValue("@PickupLocation", newShuttleReservation.PickupLocation);
cmd.Parameters.AddWithValue("@DropoffDestination", newShuttleReservation.DropoffDestination);
cmd.Parameters.AddWithValue("@PickupDateTime", newShuttleReservation.PickupDateTime);
if (newShuttleReservation.DropoffDateTime == null) //null
{
cmd.Parameters.AddWithValue("@DropoffDateTime", System.DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@DropoffDateTime", newShuttleReservation.DropoffDateTime);
}
try
{
conn.Open();
result = cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(result);
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/10
///
/// constructor to create shuttleReservation with three parameters.
/// </summary>
public ShuttleReservationDetail(ShuttleReservation selectedShuttleReservation, IShuttleReservationManager shuttleReservationManager = null, IEmployeeManager employeeManager = null, IGuestManager guestManager = null)
{
_selectedShuttleReservation = selectedShuttleReservation;
if (shuttleReservationManager == null)
{
shuttleReservationManager = new ShuttleReservationManager();
}
if (employeeManager == null)
{
employeeManager = new EmployeeManager();
}
if (guestManager == null)
{
guestManager = new GuestManager();
}
_shuttleReservationManager = shuttleReservationManager;
_employeeManager = employeeManager;
_guestManager = guestManager;
InitializeComponent();
txtPickupLocation.Text = _selectedShuttleReservation.PickupLocation;
txtDropoffDestination.Text = _selectedShuttleReservation.DropoffDestination;
this.Title = "Update Shuttle Reservatiion";
cboGuestLast.IsEnabled = false;
cboGuestFirst.IsEnabled = false;
cboGuestPhoneNumber.IsEnabled = false;
cboEmployeeLast.IsEnabled = false;
cboEmployeeFirst.IsEnabled = false;
if (_selectedShuttleReservation.DropoffDateTime != null)
{
btnDropoffSubmit.IsEnabled = false;
}
_isUpdate = true;
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to select shuttle reservation by shuttlereservationID
/// </summary>
public ShuttleReservation RetrieveShuttleReservationByShuttleReservationID(int shuttleReservationID)
{
ShuttleReservation shuttleReservation = new ShuttleReservation();
var cmdText = @"sp_retrieve_shuttle_reservation_by_id";
var conn = DBConnection.GetDbConnection();
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ShuttleReservationID", shuttleReservationID);
try
{
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.HasRows)
{
shuttleReservation.ShuttleReservationID = reader.GetInt32(0);
shuttleReservation.GuestID = reader.GetInt32(1);
shuttleReservation.EmployeeID = reader.GetInt32(2);
shuttleReservation.PickupLocation = reader.GetString(3);
shuttleReservation.DropoffDestination = reader.GetString(4);
shuttleReservation.PickupDateTime = reader.GetDateTime(5);
shuttleReservation.DropoffDateTime = reader.GetDateTime(6);
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(shuttleReservation);
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to retrieve all shuttlereservation
/// </summary>
public List <ShuttleReservation> RetrieveAllShuttleReservations()
{
List <ShuttleReservation> shuttleReservations = new List <ShuttleReservation>();
var conn = DBConnection.GetDbConnection();
var cmdText = @"sp_retrieve_all_shuttle_reservations";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
object test = reader[6];
DateTime?dropoff;
if (test == DBNull.Value)
{
dropoff = null;
}
else
{
dropoff = reader.GetDateTime(6);
}
var shuttleReservation = new ShuttleReservation()
{
ShuttleReservationID = reader.GetInt32(0),
GuestID = reader.GetInt32(1),
EmployeeID = reader.GetInt32(2),
PickupLocation = reader.GetString(3),
DropoffDestination = reader.GetString(4),
PickupDateTime = reader.GetDateTime(5),
DropoffDateTime = dropoff,
Active = reader.GetBoolean(7)
};
shuttleReservation.Employee = new EmployeeAccessor().RetrieveEmployeeInfo(shuttleReservation.EmployeeID);
shuttleReservation.Guest = new GuestAccessor().RetrieveGuestInfo(shuttleReservation.GuestID);
shuttleReservations.Add(shuttleReservation);
}
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(shuttleReservations);
}
/// <summary>
/// Eduardo Colon
/// Created: 2019/03/20
///
/// method to save shuttle reservation.
/// </summary>
private void btnSave_Click(object sender, RoutedEventArgs e)
{
//validation for empty string
if (cboHour.Text == "" || cboMinute.Text == "")
{
MessageBox.Show("Hour and Minutes can't be Blank");
return;
}
if (dtpPickupDate.Text == "")
{
MessageBox.Show("Pickup Date can't be Blank");
return;
}
// make sure they fill out all of the stuff correctly
if (txtPickupLocation.Text == "")
{
MessageBox.Show("Pickup Location can't be Blank");
txtPickupLocation.Focus();
return;
}
if (txtDropoffDestination.Text == "")
{
MessageBox.Show("Dropoff Destination can't be Blank");
return;
}
if (cboGuestLast.Text == "" || cboGuestLast.Text == "" || cboGuestPhoneNumber.Text == "")
{
MessageBox.Show("Guest Last,Fist and Phone# can't be Blank");
return;
}
if (cboEmployeeLast.Text == "" || cboEmployeeFirst.Text == "")
{
MessageBox.Show("Employee Last Name and First Name can't be Blank");
return;
}
var hour = (int)cboHour.SelectedValue;
var minute = int.Parse((String)cboMinute.SelectedValue);
if (dtpPickupDate.Text == "")
{
MessageBox.Show(" Pickup Date can't be Blank");
return;
}
var full = new DateTime(dtpPickupDate.SelectedDate.Value.Year, dtpPickupDate.SelectedDate.Value.Month, dtpPickupDate.SelectedDate.Value.Day, hour, minute, 0);
ShuttleReservation newShuttleReservation = new ShuttleReservation()
{
PickupLocation = txtPickupLocation.Text,
DropoffDestination = txtDropoffDestination.Text,
PickupDateTime = full,
DropoffDateTime = null,
EmployeeID = _employeeInfo.Where(g => g.LastName == (string)cboEmployeeLast.SelectedValue && g.FirstName == (string)cboEmployeeFirst.SelectedValue).Select(g => g.EmployeeID).First(),
GuestID = _guestInfo.Where(g => g.LastName == (string)cboGuestLast.SelectedValue && g.FirstName == (string)cboGuestFirst.SelectedValue).Select(g => g.GuestID).First(),
};
if (_isUpdate)
{
newShuttleReservation.Active = _selectedShuttleReservation.Active;
try
{
_shuttleReservationManager.UpdateShuttleReservation(_selectedShuttleReservation, newShuttleReservation);
this.DialogResult = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
else
{
try
{
if (_shuttleReservationManager.CreateShuttleReservation(newShuttleReservation) == 0)
{
MessageBox.Show("Shuttler Reservation Saved");
this.DialogResult = true;
}
}
catch (ArgumentException ex)
{
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace);
return;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
this.Close();
}
public int InsertShuttleReservation(ShuttleReservation newShuttleReservation)
{
_shuttleReservation.Add(newShuttleReservation);
return(newShuttleReservation.ShuttleReservationID);
}
