/// <summary>
/// Justin Pennington
/// Created: 2015/02/14
/// Adds a new event item in the database, using an event object that is passed in
/// </summary>
/// <param name="newEvent">The Event object to be added</param>
/// <returns>number of rows updated in db</returns>
public static int AddEvent(Event newEvent)
{
//Connect To Database
var conn = DatabaseConnection.GetDatabaseConnection();
var cmdText = "spInsertEventItem";
var cmd = new SqlCommand(cmdText, conn);
var rowsAffected = 0;
cmd.CommandType = CommandType.StoredProcedure;
//Set up Parameters For the Stored Procedure
cmd.Parameters.AddWithValue("@EventItemName", newEvent.EventItemName);
cmd.Parameters.AddWithValue("@EventTypeID", newEvent.EventTypeID);
cmd.Parameters.AddWithValue("@EventOnsite", newEvent.OnSite);
cmd.Parameters.AddWithValue("@Transportation", newEvent.Transportation);
cmd.Parameters.AddWithValue("@EventDescription", newEvent.Description);
try
{
conn.Open();
rowsAffected = cmd.ExecuteNonQuery();
if (rowsAffected == 0)
{
throw new ApplicationException("Concurrency Violation");
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return rowsAffected;
}
/// <summary>
/// Justin Pennington
/// Created: 2015/02/14
/// Changes the event from active to inactive
/// </summary>
/// <param name="eventToBeDeleted">The Event to be set inactive</param>
/// <returns>returns number of rows affected</returns>
public static int DeleteEventItem(Event eventToBeDeleted)
{
var conn = DatabaseConnection.GetDatabaseConnection();
var cmdText = "spDeleteEventItem";
var cmd = new SqlCommand(cmdText, conn);
var rowsAffected = 0;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@EventItemName", eventToBeDeleted.EventItemName);
cmd.Parameters.AddWithValue("@EventItemID", eventToBeDeleted.EventItemID);
cmd.Parameters.AddWithValue("@EventTypeID", eventToBeDeleted.EventTypeID);
cmd.Parameters.AddWithValue("@Transportation", eventToBeDeleted.Transportation);
cmd.Parameters.AddWithValue("@EventDescription", eventToBeDeleted.Description);
cmd.Parameters.AddWithValue("@EventOnsite", eventToBeDeleted.OnSite);
try
{
conn.Open();
rowsAffected = cmd.ExecuteNonQuery();
if (rowsAffected == 0)
{
throw new ApplicationException("Concurrency Violation");
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return rowsAffected; // needs to be rows affected
}
//creates a new event item in the database, using an event object that is passed in
public static int addEvent(Event newEvent)
{
var conn = DatabaseConnection.GetDBConnection();
string query = "INSERT INTO EventItem (EventItemName, EventStartTime, EventEndTime, MaxNumberOfGuests," +
"CurrentNumberOfGuests, EventTypeID, PricePerPerson, EventOnsite, Transportation, EventDescription, Active) " +
"VALUES(@EventItemName, EventStartTime, EventEndTime, MaxNumberOfGuests, CurrentNumberOfGuests, EventTypeID" +
", PricePerPerson, EventOnsite, Transportation, EventDescription, Active)";
var cmd = new SqlCommand(query, conn);
cmd.Parameters.AddWithValue("@EventItemName", newEvent.EventItemName);
cmd.Parameters.AddWithValue("@EventStartTime", newEvent.EventStartDate);
cmd.Parameters.AddWithValue("@EventEndTime", newEvent.EventEndDate);
cmd.Parameters.AddWithValue("@MaxNumberOfGuests", newEvent.MaxNumGuests);
cmd.Parameters.AddWithValue("@EventTypeID", newEvent.EventTypeID);
cmd.Parameters.AddWithValue("@PricePerPerson", newEvent.PricePerPerson);
cmd.Parameters.AddWithValue("@EventOnsite", newEvent.OnSite);
cmd.Parameters.AddWithValue("@Transportation", newEvent.Transportation);
cmd.Parameters.AddWithValue("@EventDescription", newEvent.Description);
cmd.Parameters.AddWithValue("@Active", newEvent.Active);
try
{
conn.Open();
return cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
}
public void DeleteEvent_ValidEvent()
{
int expected = 1;
setup();
EventAccessor.AddEvent(eventToTest);
eventToTest = getEventObjectID(list);
int actual = EventAccessor.DeleteEventItem(eventToTest);
EventAccessor.DeleteEventTestItem(eventToTest);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Matt Lapka
/// Created: 2015/04/12
/// Sends event update information to BLL and validates data
/// </summary>
/// <param name="eventItemID">event ID to update</param>
public void UpdateEvent(int eventItemID)
{
int errorCount = 0;
try
{
Event myEvent = _listedEvents
.Where(ev => ev.EventItemID == eventItemID).FirstOrDefault();
Event newEvent = new Event(myEvent.EventItemID, myEvent.EventItemName, myEvent.Transportation, myEvent.EventTypeID, myEvent.OnSite, myEvent.ProductID, myEvent.Description, myEvent.Active);
if (String.Format("{0}", Request.Form["name"]).Trim().ValidateAlphaNumeric(1, 255))
{
newEvent.EventItemName = String.Format("{0}", Request.Form["name"]).Trim();
}
else
{
errorCount++;
showError("You must enter a valid Event Name!");
return;
}
//Created programatically so don't need to be validated
newEvent.EventTypeID = int.Parse(Request.Form["type"]);
newEvent.Transportation = bool.Parse(Request.Form["transport"]);
newEvent.OnSite = bool.Parse(Request.Form["onsite"]);
if (String.Format("{0}", Request.Form["description"]).Trim().ValidateCompanyName(1, 255))
{
newEvent.Description = String.Format("{0}", Request.Form["description"]).Trim();
}
else
{
errorCount++;
showError("You must enter a valid Description!" + String.Format("{0}", Request.Form["description"]).Trim());
return;
}
lblError.Text = "";
EventManager.EventResult result;
if (myEvent != null)
{
result = _myManager.EditEvent(myEvent, newEvent);
return;
}
}
catch (Exception ex)
{
lblMessage.Text = "Event Updating Event: " + ex.Message;
Page.ClientScript.RegisterStartupScript(this.GetType(), "showit", "showMessage()", true);
}
}
/// <summary>
/// Hunter Lind
/// Created: 2015/2/23
/// Fills out our form with information from NewEvent.
/// Also saves an Unrevised version of NewEvent.
/// </summary>
/// <param name="eventToEdit">The Event we are going to edit</param>
/// <param name="readOnly">Make the form ReadOnly.</param>
/// <exception cref="WanderingTurtleException">Occurrs making components readonly</exception>
public AddEditEvent(Event eventToEdit, bool readOnly = false)
{
OriginalEvent = eventToEdit;
_eventToSubmit.Active = eventToEdit.Active;
_eventToSubmit.Description = eventToEdit.Description;
_eventToSubmit.EventTypeID = eventToEdit.EventTypeID;
_eventToSubmit.OnSite = eventToEdit.OnSite;
_eventToSubmit.Transportation = eventToEdit.Transportation;
_eventToSubmit.EventItemName = eventToEdit.EventItemName;
_eventToSubmit.EventItemID = eventToEdit.EventItemID;
Setup();
Title = "Editing Event: " + OriginalEvent.EventItemName;
if (readOnly) { (Content as Panel).MakeReadOnly(BtnCancel); }
}
/// <summary>
/// Matt Lapka
/// Created: 2015/01/31
/// Add a single Event object
/// </summary>
/// <param name="newEvent">The Event object to be added to the database</param>
/// <returns>An enumerated result depicting success or failure</returns>
public EventResult AddNewEvent(Event newEvent)
{
try
{
if (EventAccessor.AddEvent(newEvent) == 1)
{
//refresh cache
DataCache._currentEventList = EventAccessor.GetEventList();
DataCache._EventListTime = DateTime.Now;
return EventResult.Success;
}
return EventResult.NotAdded;
}
catch (ApplicationException ex)
{
return ex.Message == "Concurrency Violation" ? EventResult.ChangedByOtherUser : EventResult.DatabaseError;
}
catch (Exception)
{
return EventResult.DatabaseError;
}
}
//requires: Event object, Boolean value for active/inactive
//returns number of rows affected
public static int deleteEvent(Event newEvent)
{
var conn = DatabaseConnection.GetDBConnection();
var cmdText = "spDeleteEvent";
var cmd = new SqlCommand(cmdText, conn);
var rowsAffected = 0;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Active", 0);
cmd.Parameters.AddWithValue("@original_EventItemName", newEvent.EventItemName);
cmd.Parameters.AddWithValue("@original_EventID", newEvent.EventItemID);
cmd.Parameters.AddWithValue("@original_EventStartTime", newEvent.EventStartDate);
cmd.Parameters.AddWithValue("@original_EventEndTime", newEvent.EventEndDate);
cmd.Parameters.AddWithValue("@original_MaxNumberOfGuests", newEvent.MaxNumGuests);
cmd.Parameters.AddWithValue("@original_PricePerPerson", newEvent.PricePerPerson);
cmd.Parameters.AddWithValue("@original_Transportation", newEvent.Transportation);
cmd.Parameters.AddWithValue("@original_EventDescription", newEvent.Description);
cmd.Parameters.AddWithValue("@original_Active", newEvent.Active);
try
{
conn.Open();
rowsAffected = cmd.ExecuteNonQuery();
if (rowsAffected == 0)
{
throw new ApplicationException("Concurrency Violation");
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return rowsAffected; // needs to be rows affected
}
/// <summary>
/// Justin Pennington
/// Created: 2015/02/14
/// Retrieve data for an Event, create an object using data with retrieved data, and return the object that is created
/// </summary>
/// <remarks>
/// Bryan Hurst
/// Updated: 2015/04/24
///
/// Added while loop and CommandType.StoredProcedure setting
/// </remarks>
/// <param name="eventID">The EventID matching the Event to be retrieved</param>
/// <returns>The Event requested via the EventID</returns>
public static Event GetEvent(string eventID)
{
var theEvent = new Event();
// set up the database call
var conn = DatabaseConnection.GetDatabaseConnection();
string cmdText = "spSelectEventItem";
var cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@EventItemID", eventID);
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows == true)
{
while (reader.Read())
{
theEvent.EventItemID = reader.GetInt32(0);
theEvent.EventItemName = reader.GetString(1);
theEvent.EventTypeID = reader.GetInt32(2);
theEvent.OnSite = reader.GetBoolean(3);
theEvent.Transportation = reader.GetBoolean(4);
theEvent.Description = reader.GetString(5);
theEvent.Active = reader.GetBoolean(6);
}
}
else
{
var ax = new ApplicationException("Data not found!");
throw ax;
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return theEvent;
}
/// <summary>
/// Matt Lapka
/// Created: 2015/03/26
/// Sends event information to BLL and validates data
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnSubmitEvent_Click(object sender, EventArgs e)
{
bool stop = false;
int errorCount = 0;
//validate!
if (!txtEventName.Text.ValidateAlphaNumeric(1))
{
txtEventName.ToolTip = "You must enter a valid event name!";
txtEventName.BorderColor = Color.Red;
stop = true;
errorCount++;
}
if (comboEventTypeList.SelectedIndex < 1)
{
comboEventTypeList.ToolTip = "You must select an event type!";
comboEventTypeList.BorderColor = Color.Red;
stop = true;
errorCount++;
}
if (String.IsNullOrEmpty(txtDescription.Text))
{
txtDescription.ToolTip = "Please enter a brief description";
txtDescription.BorderColor = Color.Red;
stop = true;
errorCount++;
}
if (radOnSite.SelectedIndex < 0)
{
radOnSite.ToolTip = "Please select if this will be an on site event.";
radOnSite.BorderColor = Color.Red;
stop = true;
errorCount++;
}
if (radTransportation.SelectedIndex < 0)
{
radTransportation.ToolTip = "Please indicate whether or not you will provide transportation to the event.";
radTransportation.BorderColor = Color.Red;
stop = true;
//only add error count if this questions is visible
if (radTransportation.Visible)
{
errorCount++;
}
}
if (stop)
{
showError("You have " + errorCount + " errors that need to be fixed.");
return;
}
else
{
//reset border colors
txtEventName.BorderColor = Color.Black;
txtDescription.BorderColor = Color.Black;
comboEventTypeList.BorderColor = Color.Black;
radTransportation.BorderColor = Color.Black;
radOnSite.BorderColor = Color.Black;
try
{
//create new Event
Event currentEvent = new Event();
currentEvent.EventItemName = txtEventName.Text;
currentEvent.Description = txtDescription.Text;
int typeID = 0;
//we know that the selected value (event type id) is an int so no need to validate
int.TryParse(comboEventTypeList.SelectedValue, out typeID);
currentEvent.EventTypeID = typeID;
bool onsite;
bool transportation;
bool.TryParse(radOnSite.SelectedValue, out onsite);
bool.TryParse(radTransportation.SelectedValue, out transportation);
currentEvent.OnSite = onsite;
currentEvent.Transportation = transportation;
EventManager.EventResult result = _myEventManager.AddNewEvent(currentEvent);
if (result == EventManager.EventResult.Success)
{
lblMessage.Text = "Event Successfully Added!";
Page.ClientScript.RegisterStartupScript(this.GetType(), "showit", "showMessage()", true);
}
clearForm();
}
catch (Exception ex)
{
showError(ex.Message);
}
}
}
public void GetEvent_Valid()
{
setup();
string expected = eventToTest.EventItemName;
EventAccessor.AddEvent(eventToTest);
eventToEdit = getEventObjectID(list);
Event actual = EventAccessor.GetEvent(eventToEdit.EventItemID.ToString());
EventAccessor.DeleteEventTestItem(eventToTest);
Assert.AreEqual(expected, actual.EventItemName);
}
/// <summary>
/// Miguel Santana
/// Created: 2015/04/09
/// Opens the addevent ui with a record to edit or a blank screen
/// </summary>
/// <param name="selectedEvent"></param>
/// <param name="readOnly"></param>
private void OpenEvent(Event selectedEvent = null, bool readOnly = false)
{
try
{
if (selectedEvent == null)
{
if (new AddEditEvent().ShowDialog() == false) return;
Refresh();
}
else
{
if (new AddEditEvent(selectedEvent, readOnly).ShowDialog() == false) return;
if (readOnly) return;
Refresh();
}
}
catch (Exception ex)
{
throw new WanderingTurtleException(this, ex);
}
}
/// <summary>
/// Bryan Hurst
/// Created: 2015/04/03
/// Deletes information concerning the test event
/// </summary>
/// <param name="testEvent"></param>
/// <returns></returns>
public int DeleteTestEvent(Event testEvent)
{
try
{
return EventAccessor.DeleteEventTestItem(testEvent);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Matt Lapka
/// Created: 2015/01/31
/// "Delete" a single Event object (make inactive)
/// </summary>
/// <param name="eventToDelete">The Event object to be deleted/made inactive</param>
/// <returns>An enumerated result depicting success or fail</returns>
public EventResult ArchiveAnEvent(Event eventToDelete)
{
try
{
if (EventAccessor.DeleteEventItem(eventToDelete) == 1)
{
//update cache
DataCache._currentEventList = EventAccessor.GetEventList();
DataCache._EventListTime = DateTime.Now;
return EventResult.Success;
}
return EventResult.NotChanged;
}
catch (ApplicationException ex)
{
return ex.Message == "Concurrency Violation" ? EventResult.ChangedByOtherUser : EventResult.DatabaseError;
}
catch (Exception)
{
return EventResult.DatabaseError;
}
}
/// <summary>
/// Hunter Lind
/// Created: 2015/2/23
/// Creates an event to replace the old version of itself.
/// </summary>
private async void AddNewEvent()
{
var newEvent = new Event();
try
{
newEvent.EventItemName = TxtEventName.Text;
// On-site //
if (RadOnSiteYes.IsChecked == true)
{
newEvent.OnSite = true;
}
else if (RadOnSiteNo.IsChecked == true)
{
newEvent.OnSite = false;
}
else
{
throw new InputValidationException(RadOnSite, "Please fill in the on site field");
}
// Provided transport //
if (RadTranspNo.IsChecked == true)
{
newEvent.Transportation = false;
}
else if (RadTranspYes.IsChecked == true)
{
newEvent.Transportation = true;
}
else
{
throw new InputValidationException(RadTransp, "Please fill out the Transportation field");
}
newEvent.Description = TxtDescrip.Text;
if (CboxType.SelectedItem != null)
{
newEvent.EventTypeID = ((EventType)CboxType.SelectedItem).EventTypeID;
}
else
{
throw new InputValidationException(CboxType, "Please select an event type!");
}
if (String.IsNullOrEmpty(TxtEventName.Text))
{
throw new InputValidationException(TxtEventName, "Please enter an event name.");
}
EventManager.EventResult result = _eventManager.AddNewEvent(newEvent);
if (result == EventManager.EventResult.Success)
{
await this.ShowMessageDialog("Successfully Added Event");
DialogResult = true;
Close();
}
}
catch (Exception ex)
{
if (ex is InputValidationException) { throw new InputValidationException((InputValidationException)ex); }
throw new WanderingTurtleException(this, ex, "Error adding new event");
}
}
/// <summary>
/// Justin Pennington
/// Created: 2015/02/14
/// Retrieves all Active Events and returns a List of Event objects
/// </summary>
/// <returns>List object containing Event objects returned by the database</returns>
public static List<Event> GetEventList()
{
var EventList = new List<Event>();
// set up the database call
var conn = DatabaseConnection.GetDatabaseConnection();
string cmdText = "spSelectAllEventItems";
var cmd = new SqlCommand(cmdText, conn);
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows == true)
{
while (reader.Read())
{
var currentEvent = new Event();
currentEvent.EventItemID = reader.GetInt32(0);
currentEvent.EventItemName = reader.GetString(1);
currentEvent.EventTypeID = reader.GetInt32(2);
currentEvent.OnSite = reader.GetBoolean(3);
currentEvent.Transportation = reader.GetBoolean(4);
currentEvent.Description = reader.GetString(5);
currentEvent.Active = reader.GetBoolean(6);
currentEvent.EventTypeName = reader.GetString(7);
EventList.Add(currentEvent);
}
}
else
{
var ax = new ApplicationException("Data not found!");
throw ax;
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return EventList;
}
/// <summary>
/// Justin Pennington
/// Created: 2015/02/04
///
/// Updates an Event object/record
/// </summary>
/// <param name="oldEvent">The Event object to be updated</param>
/// <param name="newEvent">The Event object with the updated information</param>
/// <returns>Returns the number of rows affected (should be 1)</returns>
public static int UpdateEvent(Event oldEvent, Event newEvent)
{
var conn = DatabaseConnection.GetDatabaseConnection();
var cmdText = "spUpdateEventItem";
var cmd = new SqlCommand(cmdText, conn);
var rowsAffected = 0;
// set command type to stored procedure and add parameters
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@EventItemName", newEvent.EventItemName);
cmd.Parameters.AddWithValue("@EventTypeID", newEvent.EventTypeID);
cmd.Parameters.AddWithValue("@EventOnsite", newEvent.OnSite);
cmd.Parameters.AddWithValue("@Transportation", newEvent.Transportation);
cmd.Parameters.AddWithValue("@EventDescription", newEvent.Description);
cmd.Parameters.AddWithValue("@EventItemID", oldEvent.EventItemID);
cmd.Parameters.AddWithValue("@originalEventItemName", oldEvent.EventItemName);
cmd.Parameters.AddWithValue("@originalEventTypeID", oldEvent.EventTypeID);
cmd.Parameters.AddWithValue("@originalEventOnsite", oldEvent.OnSite);
cmd.Parameters.AddWithValue("@originalTransportation", oldEvent.Transportation);
cmd.Parameters.AddWithValue("@originalEventDescription", oldEvent.Description);
try
{
conn.Open();
rowsAffected = cmd.ExecuteNonQuery();
if (rowsAffected == 0)
{
throw new ApplicationException("Concurrency Violation");
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return rowsAffected; // needs to be rows affected
}
public static Event getEvent(String eventID)
{
var theEvent = new Event();
// set up the database call
var conn = DatabaseConnection.GetDBConnection();
string query = "SELECT EventItemID, EventItemName, EventStartTime, EventEndTime, MaxNumberOfGuests," +
"CurrentNumberOfGuests, MinNumberOfGuests, EventTypeID, PricePerPerson, EventOnsite, Transportation, EventDescription, Active " +
"FROM EventItem WHERE EventItemID = " + eventID;
var cmd = new SqlCommand(query, conn);
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows == true)
{
theEvent.EventItemID = reader.GetInt32(0);
theEvent.EventItemName = reader.GetString(1);
theEvent.EventEndDate = (DateTime)reader.GetValue(3);
theEvent.MaxNumGuests = reader.GetInt32(4);
theEvent.CurrentNumGuests = reader.GetInt32(5);
theEvent.MinNumGuests = reader.GetInt32(6);
theEvent.EventTypeID = reader.GetInt32(7);
theEvent.PricePerPerson = reader.GetDecimal(8);
theEvent.OnSite = reader.GetBoolean(9);
theEvent.Transportation = reader.GetBoolean(10);
theEvent.Description = reader.GetString(11);
theEvent.Active = reader.GetBoolean(12);
}
else
{
var ax = new ApplicationException("Data not found!");
throw ax;
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return theEvent;
}
private void toTestUpdate()
{
var myList = myMan.RetrieveEventList();
foreach (var item in myList)
{
if (item.Description == "This is a test descrip")
{
toTest = item;
}
}
}
/// <summary>
/// Hunter Lind
/// Created: 2015/2/23
/// Opens a dialog to confirm archival of an event record
/// List is refreshed after archival
/// </summary>
/// <param name="selectedEvent"></param>
private async void ArchiveEvent(Event selectedEvent)
{
ResultsArchive results = _myProductManager.CheckToArchiveEvent(selectedEvent.EventItemID);
if (results == ResultsArchive.OkToArchive)
{
// Configure the message box to be displayed
string messageBoxText = "Are you sure you want to delete this event?";
string caption = "Delete Event?";
// Display message box
MessageDialogResult result = await this.ShowMessageDialog(messageBoxText, caption, MessageDialogStyle.AffirmativeAndNegative);
// Process message box results
switch (result)
{
case MessageDialogResult.Affirmative:
try
{
_myEventManager.ArchiveAnEvent(selectedEvent);
Refresh();
}
catch (Exception ex)
{
throw new WanderingTurtleException(this, ex);
}
break;
case MessageDialogResult.Negative:
// User pressed No button
// ...
break;
}
}
else
{
throw new WanderingTurtleException(this, "Event cannot be archive because it has active listings associated.");
}
}
