/// <summary>
/// Matt Lapka
/// Created: 2015/01/31
// Retrieve a list of active Event objects
/// </summary>
/// <returns>A List object containing Event objects retrieved from the database</returns>
public List <Event> RetrieveEventList()
{
double cacheExpirationTime = 5; //how long the cache should live (minutes)
var now = DateTime.Now;
try
{
if (DataCache._currentEventList == null)
{
//data hasn't been retrieved yet. get data, set it to the cache and return the result.
var list = EventAccessor.GetEventList();
DataCache._currentEventList = list;
DataCache._EventListTime = now;
return(list);
}
//check time. If less than 5 min, return cache
if (now > DataCache._EventListTime.AddMinutes(cacheExpirationTime))
{
//get new list from DB
var list = EventAccessor.GetEventList();
//set cache to new list and update time
DataCache._currentEventList = list;
DataCache._EventListTime = now;
return(list);
}
return(DataCache._currentEventList);
}
catch (Exception ex)
{
throw ex;
}
}
public void OnDeleteTopic(Topic topic, IDObjects.NumberSet linksAffected, EventAccessor eventAccessor)
{
Monitor.Enter(linksToResolve);
try
{ linksToResolve.Add(linksAffected); }
finally
{ Monitor.Exit(linksToResolve); }
// Check newTopicIDsByEndingSymbol just in case. We don't want to leave any references to a deleted topic.
Monitor.Enter(newTopicIDsByEndingSymbol);
try
{
IDObjects.NumberSet newTopicIDs = newTopicIDsByEndingSymbol[topic.Symbol.EndingSymbol];
if (newTopicIDs != null)
{
newTopicIDs.Remove(topic.TopicID);
}
}
finally
{ Monitor.Exit(newTopicIDsByEndingSymbol); }
}
public void OnDeleteLink(Link link, EventAccessor eventAccessor)
{
// Just in case, so there's no hanging references
lock (linksToResolve)
{ linksToResolve.Remove(link.LinkID); }
}
public int CalculateAvailableTickets(Event selectedEvent)
{
// returns a count of available tickets
int tickets = 0;
int maxTickets = selectedEvent.MaxSeats;
try
{
// check if there are any tickets reserved already
if (0 != EventAccessor.RetrieveCountEventIDInRoomEvents(selectedEvent.EventID))
{
// if there is, subtract that amount from the maximum amount
tickets = maxTickets - EventAccessor.RetrieveCountOfPurchasedTickets(selectedEvent.EventID);
}
else
{
// none have been purchased yet, all the tickets remain
tickets = maxTickets;
}
}
catch (Exception)
{
throw;
}
return(tickets);
}
public void GetEvent_Invalid()
{
setup();
eventToEdit.EventItemID = 9999;
Event actual = EventAccessor.GetEvent(eventToEdit.EventItemID.ToString());
}
/// <summary>
/// Matt Lapka
/// Created: 2015/01/31
/// Retrieve a single Event object from the Data Access layer with an eventItemID
/// </summary>
/// <param name="eventItemID">The EventItemID to search for</param>
/// <returns>The Event object whose ID matches the passed parameter</returns>
public Event RetrieveEvent(string eventItemID)
{
var now = DateTime.Now;
double cacheExpirationTime = 5;
try
{
if (DataCache._currentEventList == null)
{
return(EventAccessor.GetEvent(eventItemID));
}
//check time. If less than 5 min, return event from cache
if (now > DataCache._EventListTime.AddMinutes(cacheExpirationTime))
{
//get event from DB
var currentEvent = EventAccessor.GetEvent(eventItemID);
return(currentEvent);
}
else
{
//get event from cached list
var list = DataCache._currentEventList;
Event currentEvent = list.FirstOrDefault(e => e.EventItemID.ToString() == eventItemID);
if (currentEvent != null)
{
return(currentEvent);
}
throw new ApplicationException("Event not found.");
}
}
catch (Exception ex)
{
throw ex;
}
}
public List <Event> GetUpcomingEvents(bool active = true)
{
List <Event> events = null;
// limit upcoming events to those within the next 10 days.
DateTime limit = DateTime.Today.AddDays(10.0);
int limitDay = limit.Day;
int limitMonth = limit.Month;
int limitYear = limit.Year;
// make sure it is formatted for Sql
string limitDate = limitMonth + "-" + limitDay + "-" + limitYear;
try
{
events = EventAccessor.RetrieveUpcomingEvents(limitDate, active);
formatTimeForEvents(events);
}
catch (Exception)
{
throw;
}
return(events);
}
// Group: CodeDB.IChangeWatcher Functions
// __________________________________________________________________________
public void OnAddTopic(Topic topic, EventAccessor eventAccessor)
{
Monitor.Enter(newTopicIDsByEndingSymbol);
try
{
if (beforeFirstResolve && EngineInstance.Config.ReparseEverything)
{
// We don't need to track newTopicIDsByEndingSymbol in this case because the entire output will
// be reparsed and every link will be re-added. Thus every link will be on linksToResolve and we don't
// need to worry about new topics causing existing links to need to be reresolved.
}
else
{
IDObjects.NumberSet newTopicIDs = newTopicIDsByEndingSymbol[topic.Symbol.EndingSymbol];
if (newTopicIDs == null)
{
newTopicIDs = new IDObjects.NumberSet();
newTopicIDsByEndingSymbol.Add(topic.Symbol.EndingSymbol, newTopicIDs);
}
newTopicIDs.Add(topic.TopicID);
}
}
finally
{
Monitor.Exit(newTopicIDsByEndingSymbol);
}
}
public void OnAddLink(Link link, EventAccessor eventAccessor)
{
Monitor.Enter(linksToResolve);
try
{ linksToResolve.Add(link.LinkID); }
finally
{ Monitor.Exit(linksToResolve); }
}
public void DeleteEvent_InvalidEvent()
{
int expected = 1;
setup();
eventToEdit.EventItemID = 9999;
int actual = EventAccessor.DeleteEventItem(eventToEdit);
Assert.AreEqual(expected, actual);
}
public void OnDeleteLink(Link link, EventAccessor eventAccessor)
{
// Just in case, so there's no hanging references
Monitor.Enter(linksToResolve);
try
{ linksToResolve.Remove(link.LinkID); }
finally
{ Monitor.Exit(linksToResolve); }
}
/// <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;
}
}
public void AddEvent_ValidEvent()
{
int expected = 1;
setup();
int actual = EventAccessor.AddEvent(eventToTest);
EventAccessor.DeleteEventTestItem(eventToTest);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Method for retrieving the test record Created: by these methods
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private Event getEventObjectID(List <Event> list)
{
list = EventAccessor.GetEventList();
foreach (Event item in list)
{
if (item.EventItemName.Equals("TEST"))
{
return(item);
}
}
return(new Event());
}
public void UpdateEvent_ValidEvent()
{
int expected = 1;
setup();
EventAccessor.AddEvent(eventToTest);
eventToTest = getEventObjectID(list);
int actual = EventAccessor.UpdateEvent(eventToTest, eventToEdit);
EventAccessor.DeleteEventTestItem(eventToEdit);
Assert.AreEqual(expected, actual);
}
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);
}
public List <Event> GetEventsByDate(string date)
{
// Get events by a given date
List <Event> events;
try
{
events = EventAccessor.RetrieveEventsByDate(date);
}
catch (Exception)
{
throw;
}
return(events);
}
public List <Event> GetInactiveEvents()
{
// Retrieves and returns a list of inactive events
List <Event> events = null;
try
{
events = EventAccessor.RetrieveEventsByStatus(false);
formatTimeForEvents(events);
}
catch (Exception)
{
throw;
}
return(events);
}
public List <Event> GetAllEvents()
{
// Retrieves and returns a list of all events in DB
List <Event> events = null;
try
{
events = EventAccessor.RetrieveAllEvents();
formatTimeForEvents(events);
}
catch (Exception)
{
throw;
}
return(events);
}
public Event GetEventByID(int eventID)
{
// Find a specific event by the given ID
Event selectedEvent = null;
try
{
selectedEvent = EventAccessor.RetrieveEventByID(eventID);
}
catch (Exception)
{
throw;
}
formatTimeForEvent(selectedEvent);
return(selectedEvent);
}
public void Get_ReturnsEventDataQueryable()
{
// Arrange
var mockDbSet = Events.AsQueryable().BuildMockDbSet();
var mockDbContext = new Mock <IEventDbContext>();
mockDbContext
.Setup(db => db.Events)
.Returns(mockDbSet.Object);
var eventAccessor = new EventAccessor(mockDbContext.Object);
// Act
var actualQueryable = eventAccessor.GetEventsQueryable();
// Assert
Assert.NotNull(actualQueryable);
Assert.IsAssignableFrom <IQueryable <Event> >(actualQueryable);
}
public bool AddNewEvent(Event ev)
{
// add a new event to the system.
bool wasAdded = false;
int time = stringTimeToInt(ev);
try
{
// check if it actually was added
if (1 == EventAccessor.InsertNewEvent(ev.Name, ev.Description, ev.Date, time, ev.Location, ev.MaxSeats, ev.Price, ev.AddedBy))
{
wasAdded = true;
}
}
catch (Exception)
{
throw;
}
return(wasAdded);
}
// Group: CodeDB.IChangeWatcher Functions
// __________________________________________________________________________
public void OnAddTopic(Topic topic, EventAccessor eventAccessor)
{
// We don't need to track newTopicIDsByEndingSymbol when we're reparsing everything and nothing has been resolved
// yet because the entire codebase will be reparsed and therefore every link will be re-added. Every link will thus be on
// linksToResolve and we don't need to worry about new topics causing existing links to need to be reresolved.
if ((beforeFirstResolve && EngineInstance.Config.ReparseEverything) == false)
{
lock (newTopicIDsByEndingSymbol)
{
IDObjects.NumberSet newTopicIDs = newTopicIDsByEndingSymbol[topic.Symbol.EndingSymbol];
if (newTopicIDs == null)
{
newTopicIDs = new IDObjects.NumberSet();
newTopicIDsByEndingSymbol.Add(topic.Symbol.EndingSymbol, newTopicIDs);
}
newTopicIDs.Add(topic.TopicID);
}
}
}
/// <summary>
/// Matt Lapka
/// Created: 2015/01/31
/// Edit an Event object
/// </summary>
/// <param name="oldEvent">The Event object to be updated</param>
/// <param name="newEvent">The Event object with the updated information</param>
/// <returns>An enumerated result depicting success or failure</returns>
public EventResult EditEvent(Event oldEvent, Event newEvent)
{
try
{
if (EventAccessor.UpdateEvent(oldEvent, newEvent) == 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>
/// 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);
}
}
public void EventSearch_Test()
{
//arrange
setup();
String inSearch = "Boat";
//myMan.AddNewEvent(toTest);
List <Event> expected = new List <Event>();
expected.Add(toTest);
//update cache
DataCache._currentEventList = EventAccessor.GetEventList();
DataCache._EventListTime = DateTime.Now;
// act
List <Event> myTempList = new List <Event>();
myTempList = myMan.EventSearch(inSearch);
Event[] myArray = myTempList.ToArray();
//assert
Assert.IsNotNull(myArray[0].EventItemName);
}
public List <RoomEvent> GetEventsForRoom(string roomID)
{
// return a list of rooms associated with an event
List <RoomEvent> events = null;
try
{
events = EventAccessor.RetrieveEventsByRoomID(roomID);
}
catch (Exception)
{
throw;
}
// get the total cost calculated here. It is not stored.
foreach (RoomEvent re in events)
{
re.TotalPrice = re.TicketsReserved * re.IndividualPrice;
}
return(events);
}
public int ClearOldEvents()
{
// deactivate any events in the past.
int rows = 0;
int today = DateTime.Today.Day; // current day
int month = DateTime.Today.Month; // current month
int year = DateTime.Today.Year; // current year
// format it for Sql
string currentDate = month + "-" + today + "-" + year;
try
{
EventAccessor.DeactivateOldEvents(currentDate);
}
catch (Exception)
{
throw;
}
return(rows);
}
public bool EditEvent(Event oldEvent, Event newEvent)
{
// update an event in the system
bool edited = false;
int oldTime = stringTimeToInt(oldEvent);
int newTime = stringTimeToInt(newEvent);
try
{
if (1 == EventAccessor.UpdateEvent(oldEvent.EventID, oldEvent.Name, oldEvent.Description, oldEvent.Date, oldTime,
oldEvent.Location, oldEvent.MaxSeats, oldEvent.Price, oldEvent.AddedBy, oldEvent.Active,
newEvent.Name, newEvent.Description, newEvent.Date, newTime, newEvent.Location, newEvent.MaxSeats,
newEvent.Price, newEvent.AddedBy, newEvent.Active))
{
edited = true;
}
}
catch (Exception)
{
throw;
}
return(edited);
}
internal static void event_accessors(this TextWriter trapFile, EventAccessor accessorKey, int type, string name, Event eventKey, EventAccessor unboundAccessor)
{
trapFile.WriteTuple("event_accessors", accessorKey, type, name, eventKey, unboundAccessor);
}
