//Edit an event
public OperationResult <EventsDTO> EditEvent(EventsDTO eventsDTO)
{
OperationResult <EventsDTO> result = null;
try
{
IEventsDAC eventsDAC = (IEventsDAC)DACFactory.Instance.Create(DACType.EventsDAC);
EventsDTO resultDTO = eventsDAC.EditEvent(eventsDTO);
if (resultDTO != null)
{
result = OperationResult <EventsDTO> .CreateSuccessResult(resultDTO);
}
else
{
result = OperationResult <EventsDTO> .CreateFailureResult("User With This email address does not exists");
}
}
catch (DACException dacEx)
{
result = OperationResult <EventsDTO> .CreateErrorResult(dacEx.Message, dacEx.StackTrace);
}
catch (Exception e)
{
result = OperationResult <EventsDTO> .CreateErrorResult(e.Message, e.StackTrace);
}
return(result);
}
public async Task <IActionResult> PostEvents([FromBody] EventsDTO _events)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Events events_map = Mapper.Map <Events>(_events);
_context.Event.Add(events_map);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (EventsExists(_events.Id))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetEvents", new { id = _events.Id }, _events));
}
public async Task <IActionResult> PutEvents([FromRoute] int id, [FromBody] EventsDTO _events)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != _events.Id)
{
return(BadRequest());
}
Events events_map = Mapper.Map <Events>(_events);
_context.Entry(events_map).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//Edit an event
public EventsDTO EditEvent(EventsDTO eventsDTO)
{
Event @event = new Event();
try
{
using (BookContext db = new BookContext())
{
var editEvent = db.Events.Where(e => e.EventID == eventsDTO.EventID).SingleOrDefault();
editEvent.BookTitle = eventsDTO.BookTitle;
editEvent.Description = eventsDTO.Description;
editEvent.Duration = eventsDTO.Duration;
editEvent.EventType = eventsDTO.EventType;
editEvent.Location = eventsDTO.Location;
editEvent.StartDate = editEvent.StartDate;
db.SaveChanges();
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(eventsDTO);
}
//Get Details of Events
public EventsDTO GetEventsDetails(int EventId)
{
IEventsDAC eventsDetails = (IEventsDAC)DACFactory.Instance.Create(DACType.EventsDAC);
EventsDTO resultEvent = eventsDetails.GetEventsDetails(EventId);
return(resultEvent);
}
public ActionResult EditEvent(int eventId)
{
IEventsFacade eventsFacade = (IEventsFacade)FacadeFactory.Instance.Create(FacadeType.EventsFacade);
EventsDTO eventsDTO = eventsFacade.GetEditEvent(eventId);
Event @event = new Event();
ModelConverter.ModelConverter.FillModelFromDTO(eventsDTO, @event);
return(View(@event));
}
//Get all the events
public List <List <EventsDTO> > GetEvents(int id)
{
List <List <Event> > events = new List <List <Event> >();
List <Event> pastDates = new List <Event>();
List <Event> futureDates = new List <Event>();
List <List <EventsDTO> > result = new List <List <EventsDTO> >();
try
{
using (BookContext db = new BookContext())
{
DateTime todaysDate = DateTime.Today;
//if user is admin
if (id == 1)
{
pastDates = db.Events.Where(e => e.StartDate < todaysDate).ToList();
}
else
{
pastDates = db.Events.Where(e => e.StartDate < todaysDate && e.EventType == "public").ToList();
}
events.Add(pastDates);
if (id == 1)
{
futureDates = db.Events.Where(e => e.StartDate >= todaysDate).ToList();
}
else
{
futureDates = db.Events.Where(e => e.StartDate >= todaysDate && e.EventType == "public").ToList();
}
events.Add(futureDates);
foreach (var temp in events)
{
List <EventsDTO> tempResult = new List <EventsDTO>();
foreach (var currentTemp in temp)
{
EventsDTO eventsDTO = new EventsDTO();
EntityConverter.FillDTOFromEntity(currentTemp, eventsDTO);
tempResult.Add(eventsDTO);
}
result.Add(tempResult);
}
}
}
catch (Exception ex) {
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(result);
}
public ActionResult EditEvent(Event @event)
{
EventsDTO eventsDTO = new EventsDTO();
ModelConverter.ModelConverter.FillDTOFromModel(@event, eventsDTO);
IEventsFacade eventsFacade = (IEventsFacade)FacadeFactory.Instance.Create(FacadeType.EventsFacade);
OperationResult <EventsDTO> result = eventsFacade.EditEvent(eventsDTO);
if (result.IsValid())
{
return(RedirectToAction("MyEvents", new { UserId = Session["UserId"] }));
}
return(View(@event));
}
public ActionResult <EventsDTO> Put([FromBody] EventsDTO events)
{
var value = _mapper.Map <Events>(events);
var _events = _eventsService.Atualizar(value);
if (_events != null)
{
return(Ok(_mapper.Map <EventsDTO>(_events)));
}
else
{
return(NoContent());
}
}
//Get Event's Details:-
public ActionResult EventDetails(int EventId)
{
IEventsFacade eventsFacade = (IEventsFacade)FacadeFactory.Instance.Create(FacadeType.EventsFacade);
EventsDTO result = eventsFacade.GetEventsDetails(EventId);
Event eventDetail = new Event();
ModelConverter.ModelConverter.FillModelFromDTO(result, eventDetail);
//to diaplay all comments:-
ICommentsFacade commentsFacade = (ICommentsFacade)FacadeFactory.Instance.Create(FacadeType.CommentsFacade);
List <CommentsDTO> comments = commentsFacade.ViewComments(EventId);
ViewBag.Comments = comments;
return(View(eventDetail));
}
public ActionResult CreateEvent(Event newEvent)
{
EventsDTO eventsDTO = new EventsDTO();
ModelConverter.ModelConverter.FillDTOFromModel(newEvent, eventsDTO);
eventsDTO.CreatedBy = (int)Session["UserId"];
IEventsFacade eventsFacade = (IEventsFacade)FacadeFactory.Instance.Create(FacadeType.EventsFacade);
OperationResult <EventsDTO> result = eventsFacade.CreateEvents(eventsDTO);
if (result.IsValid())
{
newEvent.EventID = result.Data.EventID;
//to print the list of all the available users to invite them:-
IUsersFacade usersFacade = (IUsersFacade)FacadeFactory.Instance.Create(FacadeType.UsersFacade);
ViewBag.Users = usersFacade.GetUsers();
}
return(View(newEvent));
}
//Get Events User is Invited to
public List <List <EventsDTO> > InvitedTo(int UserId)
{
List <List <EventsDTO> > myInvites = new List <List <EventsDTO> >();
List <EventsDTO> pastEvents = new List <EventsDTO>();
List <EventsDTO> futureEvents = new List <EventsDTO>();
DateTime todaysDate = DateTime.Today;
try
{
using (BookContext db = new BookContext())
{
var myEvent = from e in db.Events
join m in db.UserEventMappings on e.EventID equals m.EventId
join u in db.Users on m.UserId equals u.UserId
where u.UserId == UserId
select e;
if (myEvent != null)
{
foreach (var temp in myEvent)
{
EventsDTO eventsDTO = new EventsDTO();
EntityConverter.FillDTOFromEntity(temp, eventsDTO);
if (eventsDTO.StartDate < todaysDate)
{
pastEvents.Add(eventsDTO);
}
else
{
futureEvents.Add(eventsDTO);
}
}
myInvites.Add(pastEvents);
myInvites.Add(futureEvents);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(myInvites);
}
//Get event to edit
public EventsDTO GetEditEvent(int EventId)
{
EventsDTO eventsDTO = new EventsDTO();
try
{
using (BookContext db = new BookContext())
{
Event editEvent = db.Events.Where(e => e.EventID == EventId).SingleOrDefault();
EntityConverter.FillDTOFromEntity(editEvent, eventsDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(eventsDTO);
}
//Get Details of the Event
public EventsDTO GetEventsDetails(int eventId)
{
List <Event> eventDetails = new List <Event>();
EventsDTO result = new EventsDTO();
try
{
using (BookContext db = new BookContext())
{
eventDetails = db.Events.Where(e => e.EventID == eventId).ToList();
EntityConverter.FillDTOFromEntity(eventDetails[0], result);
}
return(result);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
}
public EventsDTO GetEvent(Event even, string id)
{
Location l = Database.LocationRepository.GetById(even.LocationId);
Photo photo = Database.PhotoRepository.GetById(Database.EventPhotoRepository.FindByEventId(even.Id).PhotoId);
List <string> categories = new List <string>();
foreach (var x in Database.EventCategoryRepository.FindByEventId(even.Id))
{
categories.Add(Database.CategoryRepository.GetById(x.CategoryId).Name);
}
int flag = 1;
EventVisitors visitor = Database.EventVisitorsRepository.FindEventById(even.Id, id);
if (visitor == null)
{
flag = -1;
}
else if (id == even.OwnerId)
{
flag = 0;
}
EventsDTO eventsDto = new EventsDTO
{
Id = even.Id,
Title = even.Title,
DateFrom = even.DateFrom,
DateTo = even.DateTo,
Description = even.Description,
OwnerId = even.OwnerId,
city_state = l.City,
country = l.Country,
url = photo.Url,
Categories = categories,
Ifigo = flag
};
return(eventsDto);
}
//Get events Mad by the User
/// <summary>
///
/// </summary>
/// <param name="UserId"></param>
/// <returns></returns>
public List <List <EventsDTO> > GetMyEvents(int UserId)
{
List <List <EventsDTO> > myEvents = new List <List <EventsDTO> >();
List <EventsDTO> pastEvents = new List <EventsDTO>();
List <EventsDTO> futureEvents = new List <EventsDTO>();
DateTime todaysDate = DateTime.Today;
try
{
using (BookContext db = new BookContext())
{
var myEventsList = db.Events.Where(e => e.CreatedBy == UserId).ToList();
if (myEventsList != null)
{
foreach (var temp in myEventsList)
{
var eventDTO = new EventsDTO();
EntityConverter.FillDTOFromEntity(temp, eventDTO);
if (eventDTO.StartDate < todaysDate)
{
pastEvents.Add(eventDTO);
}
else
{
futureEvents.Add(eventDTO);
}
}
myEvents.Add(pastEvents);
myEvents.Add(futureEvents);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(myEvents);
}
//Create a new Event
public EventsDTO CreateEvents(EventsDTO eventsDTO)
{
Event events = new Event();
try
{
using (BookContext db = new BookContext())
{
EntityConverter.FillEntityFromDTO(eventsDTO, events);
db.Events.Add(events);
//events.EventID
db.SaveChanges();
EntityConverter.FillDTOFromEntity(events, eventsDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message, ex);
}
return(eventsDTO);
}
public ActionResult Edit(int id)
{
// Declare pageVM
EventsViewModel model;
using (ApplicationDbContext db = new ApplicationDbContext())
{
// Get the page
EventsDTO dto = db.Events.Find(id);
// Confirm page exists
if (dto == null)
{
return(Content("The post does not exist."));
}
// Init pageVM
model = new EventsViewModel(dto);
}
// Return view with model
return(View(model));
}
public ActionResult Delete(string fullName, int id)
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
// Get the page
EventsDTO dto = db.Events.Find(id);
fullName = dto.FileName.ToString();
string fullPath = Request.MapPath("~/Images/" + fullName);
if (System.IO.File.Exists(fullPath))
{
System.IO.File.Delete(fullPath);
}
// Remove the page
db.Events.Remove(dto);
// Save
db.SaveChanges();
}
// Redirect
return(RedirectToAction("Index"));
}
public OperationResult <EventsDTO> EditEvent(EventsDTO eventsDTO)
{
IEventsBDC invitesBDC = (IEventsBDC)BDCFactory.Instance.Create(BDCType.EventsBDC);
return(invitesBDC.EditEvent(eventsDTO));
}
public OperationResult <EventsDTO> CreateEvents(EventsDTO eventsDTO)
{
IEventsBDC createEventsBDC = (IEventsBDC)BDCFactory.Instance.Create(BDCType.EventsBDC);
return(createEventsBDC.CreateEvents(eventsDTO));
}
public ActionResult Create(EventsViewModel model)
{
// Check model state
if (!ModelState.IsValid)
{
return(View(model));
}
using (ApplicationDbContext db = new ApplicationDbContext())
{
EventsDTO dto = new EventsDTO();
if (model.fileupload != null)
{
string fileName = Path.GetFileNameWithoutExtension(model.fileupload.FileName);
string extension = Path.GetExtension(model.fileupload.FileName);
fileName = fileName + DateTime.Now.ToString("yyyymmddMMss") + extension;
model.FileName = fileName;
model.FilePath = "~/Images/" + fileName;
fileName = Path.Combine(Server.MapPath("~/Images/"), fileName);
model.fileupload.SaveAs(fileName);
}
else
{
string defaultName = "";
string fileName = "default";
string extension = ".jpg";
model.FileName = defaultName;
fileName = fileName + extension;
model.FilePath = "~/Images/" + fileName;
}
// DtO Title
dto.Title = model.Title;
dto.FileName = model.FileName;
//Make sure title and slug are unique
if (db.Events.Any(x => x.Title == model.Title))
{
ModelState.AddModelError("", "That title already exists.");
return(View(model));
}
//DTO the rest
dto.Content = model.Content;
dto.UserId = User.Identity.GetUserId();
dto.Created = DateTime.Now;
dto.FilePath = model.FilePath;
dto.FileName = model.FileName;
//Save DTO
db.Events.Add(dto);
db.SaveChanges();
}
//Set TempData message
TempData["SM"] = "You have added a new event!";
//Redirect
return(RedirectToAction("Index"));
}
public ActionResult Edit(string fullName, EventsViewModel model)
{
// Check model state
if (!ModelState.IsValid)
{
return(View(model));
}
using (ApplicationDbContext db = new ApplicationDbContext())
{
if (model.fileupload != null)
{
string fileName = Path.GetFileNameWithoutExtension(model.fileupload.FileName);
string extension = Path.GetExtension(model.fileupload.FileName);
//DateTime.Now.ToString("yyyymmddMMss")
fileName = fileName + DateTime.Now.ToString("yyyymmddMMss") + extension;
model.FileName = fileName;
model.FilePath = "~/Images/" + fileName;
fileName = Path.Combine(Server.MapPath("~/Images/"), fileName);
model.fileupload.SaveAs(fileName);
}
else
{
string defaultName = "";
string fileName = "default";
string extension = ".jpg";
model.FileName = defaultName;
fileName = fileName + extension;
model.FilePath = "~/Images/" + fileName;
}
// Get page id
int id = model.Id;
// Get the page
EventsDTO dto = db.Events.Find(id);
fullName = dto.FileName.ToString();
string fullPath = Request.MapPath("~/Images/" + fullName);
if (System.IO.File.Exists(fullPath))
{
System.IO.File.Delete(fullPath);
}
// DTO the title
dto.Title = model.Title;
// Make sure title and slug are unique
if (db.Events.Where(x => x.Id != id).Any(x => x.Title == model.Title))
{
ModelState.AddModelError("", "That title already exists.");
return(View(model));
}
// DTO the rest
dto.Content = model.Content;
dto.FilePath = model.FilePath;
dto.FileName = model.FileName;
// Save the DTO
db.SaveChanges();
}
// Set TempData message
TempData["SM"] = "You have edited the post!";
// Redirect
return(RedirectToAction("Index"));
}
