public ActionResult Create(EventVM createdEvent)
{
try
{
EventDA eventDA = new EventDA();
List <EventDA> eventList = new List <EventDA>();
Mapper.Map(createdEvent, eventDA);
eventList.Add(eventDA);
bool success = DataAccessServiceController.EventService.SaveEvents(eventList);
if (success == true)
{
return(RedirectToAction("Success", "Application", new { area = "" }));
}
else
{
return(RedirectToAction("Fail", "Application", new { area = "" }));
}
}
catch (Exception e)
{
throw (new Exception("Error occured in EventsController.Create(result)"));
}
}
public static EventDA GetInstance()
{
if (instance == null)
{
instance = new EventDA();
}
return(instance);
}
//GET: Details
public ViewResult Details(int eventID)
{
EventDA eventDA = DataAccessServiceController.EventService.GetEventByID(eventID);
EventVM evnt = new EventVM();
Mapper.Map(eventDA, evnt);
return(View("Details", evnt));
}
public void TestEventDAtoVM()
{
EventDA source = new EventDA {
EventID = 1, EventName = "100 metres", EventType = "Time", IsDeleted = false, Results = new List <ResultDA>()
};
EventVM dest = new EventVM();
Assert.IsNull(dest.EventName);
Mapper.Map(source, dest);
Assert.AreEqual("100 metres", dest.EventName);
}
public ResultEntity <EventEntity> GetById(int id)
{
var validationResult = new ResultEntity <EventEntity>();
using (var eventDA = new EventDA())
{
validationResult.Value = eventDA.GetById(id);
}
return(validationResult);
}
public ResultEntity <int> GetTotalRows(DBParamEntity dbParamEntity)
{
var validationResult = new ResultEntity <int>();
using (var eventDA = new EventDA())
{
validationResult.Value = eventDA.GetTotalRows(dbParamEntity);
}
return(validationResult);
}
public ResultEntity <IEnumerable <EventEntity> > GetAll(DBParamEntity dbParamEntity)
{
var validationResult = new ResultEntity <IEnumerable <EventEntity> >();
using (var eventDA = new EventDA())
{
validationResult.Value = eventDA.GetAll(dbParamEntity);
}
return(validationResult);
}
public ResultEntity <EventEntity> Create(EventEntity eventEntity)
{
var validationResult = new ResultEntity <EventEntity>();
eventEntity.CreatedDate = DateTime.Now;
using (var eventDA = new EventDA())
{
validationResult.Value = eventDA.Create(eventEntity);
}
return(validationResult);
}
public ResultEntity <int> DeleteById(int id)
{
var validationResult = new ResultEntity <int>();
using (var eventDA = new EventDA())
{
//var ids = new int[] { id };
validationResult.Value = eventDA.Delete(id);
if (validationResult.Value != 1)
{
validationResult.Warning.Add("Failed delete record Event with ID: " + id);
return(validationResult);
}
}
return(validationResult);
}
public EventDA GetEventByID(int eventID, bool includeIsDeleted)
{
EventDA evnt = new EventDA();
List <EventDA> events = new List <EventDA>();
try
{
events = _db.Events.Where(a => a.EventID == eventID).ToList();
evnt = events.First();
}
catch (Exception e)
{
throw (new Exception("Error occured in EventService.GetEventByID()"));
}
return(evnt);
}
public ResultEntity <EventEntity> Update(EventEntity eventEntity)
{
var validationResult = new ResultEntity <EventEntity>();
eventEntity.ModifiedDate = DateTime.Now;
using (var eventDA = new EventDA())
{
var resultUpdate = eventDA.Update(eventEntity);
if (resultUpdate <= 0)
{
validationResult.Warning.Add("Failed Updating Event!");
return(validationResult);
}
validationResult.Value = eventEntity;
}
return(validationResult);
}
public bool SaveEvents(List <EventDA> events)
{
bool success = false;
try
{
foreach (EventDA e in events)
{
EventDA existEvent = new EventDA();
//check if event is valid existing event
if (e.EventID > 0)
{
//get existing event from database
existEvent = _db.Events.SingleOrDefault(a => a.EventID == e.EventID);
//update existing event
_db.Entry(existEvent).CurrentValues.SetValues(e);
//flag event as changed
_db.Entry(existEvent).State = System.Data.Entity.EntityState.Modified;
}
else if (e.EventID == 0)
{
_db.Events.Add(e);
}
}
//single call to database to save all changes
_db.SaveChanges();
success = true;
}
catch (Exception e)
{
throw (new Exception("Error occured in EventService.SaveEvents(events)"));
}
return(success);
}
public ActionResult Create(ResultVM createdResult)
{
try
{
ResultDA resultDA = new ResultDA();
List <ResultDA> resultList = new List <ResultDA>();
List <EventDA> events = DataAccessServiceController.EventService.GetEvents();
EventDA e = events.Find(x => x.EventName == createdResult.EventName);
List <AthleteDA> athletes = DataAccessServiceController.AthleteService.GetAthletes(-1);
AthleteDA a = athletes.Find(x => x.AthleteName == createdResult.AthleteName);
//send event and athlete ids to created result viewmodel depending on names chosen
createdResult.EventID = e.EventID;
createdResult.AthleteID = a.AthleteID;
Mapper.Map(createdResult, resultDA);
resultList.Add(resultDA);
bool success = DataAccessServiceController.ResultService.SaveResults(resultList);
if (success == true)
{
return(RedirectToAction("Success", "Application", new { area = "" }));
}
else
{
return(RedirectToAction("Fail", "Application", new { area = "" }));
}
}
catch (Exception e)
{
throw (new Exception("Error occured in ResultsController.Create(result)"));
}
}
public ViewResult CompareChart(int aID1, int aID2, string eventName, string timeframe)
{
try
{
List <AnalyseVM> compareList = new List <AnalyseVM>();
AthleteDA athlete1 = DataAccessServiceController.AthleteService.GetAthleteByID(aID1);
EventDA evnt = DataAccessServiceController.EventService.GetEventByName(eventName);
List <ResultDA> results1 = DataAccessServiceController.ResultService.GetResultsForAnalysis(aID1, eventName, timeframe);
results1 = results1.OrderBy(r => r.DateOfResult).ToList();
AnalyseVM analysis1 = new AnalyseVM();
AthleteDA athlete2 = DataAccessServiceController.AthleteService.GetAthleteByID(aID2);
EventDA evnt2 = DataAccessServiceController.EventService.GetEventByName(eventName);
List <ResultDA> results2 = DataAccessServiceController.ResultService.GetResultsForAnalysis(aID2, eventName, timeframe);
results2 = results2.OrderBy(r => r.DateOfResult).ToList();
AnalyseVM analysis2 = new AnalyseVM();
if (results1.Count > 0 && results2.Count > 0)
{
analysis1.AthleteID = aID1;
analysis1.AthleteName = athlete1.AthleteName;
analysis1.EventName = evnt.EventName;
analysis1.EventType = evnt.EventType;
analysis1.TimeFrame = timeframe;
analysis1.TotalNumResults = results1.Count();
List <DateTime> dates1 = new List <DateTime>();
List <double> resultValues1 = new List <double>();
//List<string> resultDates = new List<string>();
foreach (ResultDA r in results1)
{
resultValues1.Add(r.Result);
dates1.Add(r.DateOfResult);
}
//AnalyseVM store results as arrays for use in graph
analysis1.Results = resultValues1.ToArray();
analysis1.ResultDates = dates1.ToArray();
if (analysis1.EventType == "Time")
{
analysis1.BestResult = analysis1.Results.Min();
analysis1.WorstResult = analysis1.Results.Max();
analysis1.TargetResult = analysis1.BestResult * 0.95;
}
else if (analysis1.EventType == "Distance")
{
analysis1.BestResult = analysis1.Results.Max();
analysis1.WorstResult = analysis1.Results.Min();
analysis1.TargetResult = analysis1.BestResult * 1.05;
}
analysis1.AverageResult = analysis1.Results.Average();
analysis2.AthleteID = aID2;
analysis2.AthleteName = athlete2.AthleteName;
analysis2.EventName = evnt2.EventName;
analysis2.EventType = evnt2.EventType;
analysis2.TimeFrame = timeframe;
analysis2.TotalNumResults = results2.Count();
List <DateTime> dates2 = new List <DateTime>();
List <double> resultValues2 = new List <double>();
foreach (ResultDA r in results2)
{
resultValues2.Add(r.Result);
dates2.Add(r.DateOfResult);
}
//AnalyseVM store results as arrays for use in graph
analysis2.Results = resultValues2.ToArray();
analysis2.ResultDates = dates2.ToArray();
if (analysis2.EventType == "Time")
{
analysis2.BestResult = analysis2.Results.Min();
analysis2.WorstResult = analysis2.Results.Max();
analysis2.TargetResult = analysis2.BestResult * 0.95;
}
else if (analysis1.EventType == "Distance")
{
analysis2.BestResult = analysis2.Results.Max();
analysis2.WorstResult = analysis2.Results.Min();
analysis2.TargetResult = analysis2.BestResult * 1.05;
}
analysis2.AverageResult = analysis2.Results.Average();
compareList.Add(analysis1);
compareList.Add(analysis2);
return(View("CompareChart", compareList));
}
else
{
return(View("NoResults"));
}
}
catch (Exception e)
{
throw (new Exception("Error occured in AthleteController.Compare(aID1, aID2, eventName, timeframe)"));
}
}
public ViewResult AnalysisChart(int aID, string eventName, string timeframe)
{
try
{
AthleteDA athlete = DataAccessServiceController.AthleteService.GetAthleteByID(aID);
EventDA evnt = DataAccessServiceController.EventService.GetEventByName(eventName);
List <ResultDA> results = DataAccessServiceController.ResultService.GetResultsForAnalysis(aID, eventName, timeframe);
results = results.OrderBy(r => r.DateOfResult).ToList();
AnalyseVM analysis = new AnalyseVM();
if (results.Count > 0)
{
analysis.AthleteID = aID;
analysis.AthleteName = athlete.AthleteName;
analysis.EventName = evnt.EventName;
analysis.EventType = evnt.EventType;
analysis.TimeFrame = timeframe;
analysis.TotalNumResults = results.Count();
List <DateTime> dates = new List <DateTime>();
List <double> resultValues = new List <double>();
//List<string> resultDates = new List<string>();
foreach (ResultDA r in results)
{
resultValues.Add(r.Result);
dates.Add(r.DateOfResult);
}
//AnalyseVM store results as arrays for use in graph
analysis.Results = resultValues.ToArray();
analysis.ResultDates = dates.ToArray();
if (analysis.EventType == "Time")
{
analysis.BestResult = analysis.Results.Min();
analysis.WorstResult = analysis.Results.Max();
analysis.TargetResult = analysis.BestResult * 0.95;
}
else if (analysis.EventType == "Distance")
{
analysis.BestResult = analysis.Results.Max();
analysis.WorstResult = analysis.Results.Min();
analysis.TargetResult = analysis.BestResult * 1.05;
}
analysis.AverageResult = analysis.Results.Average();
return(View("AnalysisChart", analysis));
}
else
{
return(View("NoResults"));
}
}
catch (Exception e)
{
throw (new Exception("Error occured in AthleteController.AnalyseChart(aID1, aID2, eventName, timeframe)"));
}
}
public EventHandler()
{
eventDA = EventDA.GetInstance();
eventParticipantDA = EventParticipantDA.getInstance();
budgetDA = BudgetDA.GetInstance();
}
