public void DeleteEventType_Invalid()
{
setup();
eventTypeToTest.EventTypeID = 9999;
Assert.AreEqual(1, EventTypeAccessor.DeleteEventType(eventTypeToTest));
}
public void UpdateEventType_Invalid()
{
setup();
eventTypeToTest.EventTypeID = 9999;
Assert.AreEqual(1, EventTypeAccessor.UpdateEventType(eventTypeToTest, eventTypeToEdit));
}
/// <summary>
/// Matt Lapka
/// Created: 2015/02/08
/// Retrieve a list of active EventType objects from the Data Access layer
///</summary>
///<returns>list of eventType Object</returns>
public List <EventType> RetrieveEventTypeList()
{
double cacheExpirationTime = 10; //how long the cache should live (minutes)
var now = DateTime.Now;
try
{
if (DataCache._currentEventTypeList == null)
{
//data hasn't been retrieved yet. get data, set it to the cache and return the result.
var list = EventTypeAccessor.GetEventTypeList();
DataCache._currentEventTypeList = list;
DataCache._EventTypeListTime = now;
return(list);
}
//check time. If less than 5 min, return cache
if (now > DataCache._EventTypeListTime.AddMinutes(cacheExpirationTime))
{
//get new list from DB
var list = EventTypeAccessor.GetEventTypeList();
//set cache to new list and update time
DataCache._currentEventTypeList = list;
DataCache._EventTypeListTime = now;
return(list);
}
return(DataCache._currentEventTypeList);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Matt Lapka
/// Created: 2015/02/08
/// Retrieve a single EventType object from the Data Access layer with an eventTypeID
/// </summary>
/// <param name="eventTypeID">The string representing the EventTypeID to search for</param>
/// <returns>An EventType object whose ID matches the passed parameter</returns>
public EventType RetrieveEventType(string eventTypeID)
{
var now = DateTime.Now;
double cacheExpirationTime = 10;
try
{
if (DataCache._currentEventTypeList == null)
{
return(EventTypeAccessor.GetEventType(eventTypeID));
}
//check time. If less than 10 min, return event from cache
if (now > DataCache._EventTypeListTime.AddMinutes(cacheExpirationTime))
{
//get event from DB
var currentEventType = EventTypeAccessor.GetEventType(eventTypeID);
return(currentEventType);
}
else
{
//get event from cached list
var list = DataCache._currentEventTypeList;
EventType currentEventType = list.Where(e => e.EventTypeID.ToString() == eventTypeID).FirstOrDefault();
if (currentEventType != null)
{
return(currentEventType);
}
throw new ApplicationException("Event not found.");
}
}
catch (Exception ex)
{
throw ex;
}
}
public void AddEventType_Valid()
{
setup();
Assert.AreEqual(1, EventTypeAccessor.AddEventType("Test"));
TestCleanupAccessor.DeleteEventTypeTest(eventTypeToTest);
}
public void UpdateEventType_Valid()
{
setup();
EventTypeAccessor.AddEventType("Test");
eventTypeToTest = getEventTypeID(list);
Assert.AreEqual(1, EventTypeAccessor.UpdateEventType(eventTypeToTest, eventTypeToEdit));
TestCleanupAccessor.DeleteEventTypeTest(eventTypeToEdit);
}
/// <summary>
/// Method for retrieving the test record Created: by these methods
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private EventType getEventTypeID(List <EventType> list)
{
list = EventTypeAccessor.GetEventTypeList();
foreach (EventType item in list)
{
if (item.EventName.Equals("Test"))
{
return(item);
}
}
return(new EventType());
}
public List <string> RetrieveEventTypes()
{
List <string> eventTypes = null;
try
{
eventTypes = EventTypeAccessor.RetrieveAllEventTypes();
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
return(eventTypes);
}
/// <summary>
/// Gets the event type list.
/// </summary>
/// <returns>List;EventType;.</returns>
/// <exception cref="System.ApplicationException">There were no event type found.</exception>
public List <EventType> GetEventTypeList()
{
try
{
var eventTypeList = EventTypeAccessor.FetchEventTypeList();
if (eventTypeList.Count > 0)
{
return(eventTypeList);
}
else
{
throw new ApplicationException("There were no event type found.");
}
}
catch (Exception)
{
// *** we should sort the possible exceptions and return friendly messages for each
throw;
}
}
/// <summary>
/// Matt Lapka
/// Created: 2015/02/08
/// Add a single EventType object
///</summary>
///<returns>result of adding the eventtype</returns>
public EventResult AddNewEventType(string eventName)
{
try
{
if (EventTypeAccessor.AddEventType(eventName) == 1)
{
//refresh cache
DataCache._currentEventTypeList = EventTypeAccessor.GetEventTypeList();
DataCache._EventTypeListTime = 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);
}
}
/// <summary>
/// Matt Lapka
/// Created: 2015/02/08
/// "Delete" a single EventType object (make inactive)
///</summary>
///<returns>result of adding the eventtype</returns>
public EventResult ArchiveAnEventType(EventType eventTypeToDelete)
{
try
{
if (EventTypeAccessor.DeleteEventType(eventTypeToDelete) == 1)
{
//update cache
DataCache._currentEventTypeList = EventTypeAccessor.GetEventTypeList();
DataCache._EventTypeListTime = DateTime.Now;
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);
}
}
