public async Task <EventDetailsViewModel> GetEventDetails(int id)
{
var @event = await this.DbContext.Events
.Include(e => e.Dance)
.FirstOrDefaultAsync(e => e.Id == id);
if (@event == null)
{
throw new ArgumentNullException();
}
string dance = @event.Dance.Name;
var model = new EventDetailsViewModel()
{
Name = @event.Name,
Dance = dance,
Place = @event.Place,
Address = @event.Address,
PosterUrl = @event.PosterUrl,
StartDate = @event.StartDate,
EndDate = @event.EndDate
};
return(model);
}
/// <summary>
/// Home apge Event details - when user is a member, they can add comments
/// </summary>
/// <param name="userId"></param>
/// <param name="id"></param>
/// <returns></returns>
public EventDetailsViewModel GetEventDetails(string userId, int id)
{
var vm = new EventDetailsViewModel();
var eventSelected = _repo.Query <Event>().Include(e => e.Locations).Include(e => e.Comments).FirstOrDefault(e => e.Id == id);
if (userId != null)
{
vm.CanEdit = true;
vm.HasClaim = false;
}
else
{
vm.CanEdit = false;
vm.HasClaim = false;
}
vm.Event = eventSelected;
eventSelected.Views++;
_repo.SaveChanges();
//vm = convertDatesFromUtcToLocalTime(vm);
//vm = DisplayUserName(vm);
//vm.Event = EventMarkUp(vm.Event);
foreach (var comment in vm.Event.Comments)
{
var commentWriterId = comment.ApplicationUserId;
var commentWriterFirstName = _repo.Query <ApplicationUser>().Where(au => au.Id == commentWriterId).Select(au => au.FirstName).FirstOrDefault();
comment.ApplicationUserId = commentWriterFirstName;
comment.DateCreated = comment.DateCreated.ToLocalTime();
}
return(vm); //activeeventdetails
}
public ActionResult EventDetailsById(int id, string eventfulId, bool eventfulEvent)
{
if (!eventfulEvent)
{
var currentUserId = this.User.Identity.GetUserId();
var isAdmin = this.IsAdmin();
var eventDetails = this.eventsdb.Events
.Where(e => e.Id == id)
.Where(e => e.IsPublic || isAdmin || (e.AuthorId != null && e.AuthorId == currentUserId))
.Select(EventDetailsViewModel.ViewModel)
.FirstOrDefault();
var isOwner = (eventDetails != null && eventDetails.AuthorId != null &&
eventDetails.AuthorId == currentUserId);
this.ViewBag.CanEdit = isOwner || isAdmin;
return(this.PartialView("_EventDetails", eventDetails));
}
else
{
this.ViewBag.CanEdit = false;
EventDetailsViewModel result = new EventDetailsViewModel();
EventfulSearch search = new EventfulSearch();
search.Id = eventfulId;
var eventResult = search.GetEventfulDetails();
if (eventResult.description != null)
{
result.Description = HttpUtility.HtmlDecode(eventResult.description);
}
else
{
result.Description = "No additional details.";
}
result.Id = eventfulId;
List <CommentViewModel> comments = new List <CommentViewModel>();
var r = this.eventfulDb.EventfulComments.Where(c => c.EventfulId == eventfulId).ToList();
if (r != null && r.Any())
{
foreach (EventfulComment c in r)
{
CommentViewModel cView = new CommentViewModel();
cView.Text = c.Text;
cView.Author = c.AspNetUser.FullName;
comments.Add(cView);
}
}
result.Comments = comments;
return(this.PartialView("_EventDetails", result));
}
}
public IActionResult Details(int id)
{
var ev = _context.Events
.Include(p => p.Coach)
.Include(p => p.Type)
.SingleOrDefault(p => p.Id == id);
if (ev == null)
{
return(NotFound());
}
var vm = new EventDetailsViewModel {
Event = ev
};
if (User.Identity.IsAuthenticated)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
vm.IsAttending = _context.Attendances.Any(a => a.EventId == ev.Id && a.AttendeeId == userId);
vm.IsFollowing = _context.Followings.Any(a => a.FolloweeId == ev.CoachId && a.FollowerId == userId);
}
return(View(nameof(Details), vm));
}
public EventDetailsPage(EventDto article)
{
InitializeComponent();
BindingContext = model = new EventDetailsViewModel {
Event = article
};
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var match = await _context.Matchs
.Include(m => m.Sides)
.Include(m => m.Users).ThenInclude(u => u.User)
.Include(m => m.Rounds).ThenInclude(r => r.GameMap).ThenInclude(r => r.GameMap)
.Include(m => m.Rounds).ThenInclude(r => r.Sides).ThenInclude(s => s.Squads).ThenInclude(s => s.Slots).ThenInclude(s => s.AssignedUser).ThenInclude(u => u.User)
.FirstOrDefaultAsync(m => m.MatchID == id);
if (match == null)
{
return(NotFound());
}
var vm = new EventDetailsViewModel();
vm.Match = match;
vm.User = await GetUser();
if (vm.User != null)
{
vm.MatchUser = match.Users.FirstOrDefault(u => u.UserID == vm.User.UserID);
}
AdminMatchsController.SortModel(match);
return(View(vm));
}
// i found my self out of time
// so I completed using razor view engine
// and to accomplish the sent UI I did a simple hack
// by sending 2 requests to API
// one to get event details
// and the other for getting month events
public ActionResult GetEventDetails(int eventId)
{
EventDetailsViewModel viewModel = new EventDetailsViewModel();
var response = _apiConsumerClient.GetAsync("api/events/GetEventDetails?eventId=" + eventId).Result;
if (response.IsSuccessStatusCode)
{
string responseString = response.Content.ReadAsStringAsync().Result;
viewModel = JsonConvert.DeserializeObjectAsync <EventDetailsViewModel>(responseString).Result;
if (viewModel != null)
{
viewModel.MonthEventList = new MonthEventListViewModel();
viewModel.MonthEventList.MonthId = viewModel.EventDateTime.Month;
var secondResponse = _apiConsumerClient
.GetAsync("api/events/GetMonthEvents?monthId=" + viewModel.MonthEventList.MonthId).Result;
if (secondResponse.IsSuccessStatusCode)
{
responseString = secondResponse.Content.ReadAsStringAsync().Result;
viewModel.MonthEventList.Events = JsonConvert.DeserializeObjectAsync <EventViewModel[]>(responseString).Result;
}
}
}
return(View(viewModel));
}
public ActionResult Details(string id)
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var eventService = new StripeEventService();
var e = eventService.Get(id);
if (e == null)
{
return(new HttpNotFoundResult());
}
var model = new EventDetailsViewModel
{
Id = e.Id,
Created = e.Created,
LiveMode = e.LiveMode,
PendingWebhooks = e.PendingWebhooks,
Request = e.Request,
Type = e.Type,
UserId = e.UserId,
Data = e.Data
};
return(View(model));
}
public ActionResult Details(int id)
{
var eEvent = _context.Events
.Include(e => e.Instructor)
.Include(e => e.EventType)
.SingleOrDefault(e => e.Id == id);
if (eEvent == null)
{
return(HttpNotFound());
}
var viewModel = new EventDetailsViewModel {
Event = eEvent
};
if (User.Identity.IsAuthenticated)
{
var userId = User.Identity.GetUserId();
viewModel.IsAttending = _context.Attendances
.Any(a => a.EventId == eEvent.Id && a.AttendeeId == userId);
viewModel.IsFollowing = _context.Followings
.Any(f => f.FolloweeId == eEvent.InstructorId && f.FollowerId == userId);
}
return(View("Details", viewModel));
}
public ActionResult Details(int id)
{
var evento = _unitOfWork.Events.GetEvent(id);
if (evento == null)
{
return(HttpNotFound());
}
var viewModel = new EventDetailsViewModel {
Event = evento
};
if (User.Identity.IsAuthenticated)
{
var userId = User.Identity.GetUserId();
viewModel.IsFollowing = _unitOfWork.Following
.GetFollowing(userId, evento.ArtistId);
viewModel.IsAttending = _unitOfWork.Attendence
.GetAttendance(evento.Id, userId);
}
return(View(viewModel));
}
public IActionResult Details(int id, User user)
{
Session session;
EventDetailsViewModel sessionDetailsViewModel;
FeedBackViewModel feedBackViewModel;
try
{
session = _sessionRepository.GetById(id);
sessionDetailsViewModel = new EventDetailsViewModel
{
User = user,
Session = session,
Images = session.Media.Where(t => t.Type == MediaType.IMAGE).ToList(),
Files = session.Media.Where(t => t.Type == MediaType.FILE).ToList(),
Videos = session.Media.Where(t => t.Type == MediaType.VIDEO).ToList()
};
feedBackViewModel = new FeedBackViewModel()
{
Session = session
};
}
catch (SessionNotFoundException e)
{
Console.Error.WriteLine(e.StackTrace);
return(NotFound());
}
return(View(new Tuple <FeedBackViewModel, EventDetailsViewModel>(feedBackViewModel, sessionDetailsViewModel)));
}
public async Task <IActionResult> Details(string slug)
{
var evt = await _dbContext.Events.Include(x => x.Users).SingleOrDefaultAsync(x => x.Slug == slug);
if (evt == null)
{
_logger.LogInformation("Event not found for slug '{slug}'", slug);
return(RedirectToAction(nameof(Index)));
}
var model = new EventDetailsViewModel
{
Event = ModelMapper.ToEventModel(evt)
};
model.CanUserEdit = (await _authorizationService.AuthorizeAsync(User, evt, Policies.EventAdmin)).Succeeded;
model.Products = await _dbContext.Products.Where(x => x.EventId == evt.Id)
.Select(x => ModelMapper.ToProductModel(x))
.ToListAsync();
foreach (var product in model.Products)
{
if (!string.IsNullOrEmpty(product.ThumbnailFilename))
{
product.ThumbnailUrl = _fileService.ResolveFileUrl(string.Format(Constants.ImagePathFormat, evt.Slug, product.ThumbnailFilename));
}
}
return(View(model));
}
//[ActionName("GetEventDetails")]
public HttpResponseMessage GetEventDetails(long EventId)
{
EventDetailsViewModel _EventDetailsViewModel = new EventDetailsViewModel();
_EventDetailsViewModel.MESSAGE = "Event Details";
_EventDetailsViewModel.Flag = "false";
List <EventDetailsModel> _lstEventDetailsModel = new List <EventDetailsModel>();
var _Event = _db.Events.FirstOrDefault(e => e.EventId == EventId);
if (null != _Event)
{
_EventDetailsViewModel.Flag = "true";
EventDetailsModel _EventDetailsModel = new EventDetailsModel();
_EventDetailsModel.EventId = _Event.EventId;
_EventDetailsModel.EventTitle = _Event.EventTitle;
_EventDetailsModel.Image = _Event.Image;
_EventDetailsModel.Description = _Event.Description;
_EventDetailsModel.Status = _Event.Status;
_EventDetailsModel.CreatedDate = _Event.CreatedDate;
_EventDetailsModel.CreatedBy = _Event.CreatedBy;
_EventDetailsModel.EventSubHeading = "" + _Event.EventSubHeading;
_lstEventDetailsModel.Add(_EventDetailsModel);
}
_EventDetailsViewModel.EventDetailsModel = _lstEventDetailsModel;
return(Request.CreateResponse(HttpStatusCode.OK, _EventDetailsViewModel));
}
/// <summary>
/// My Event and Admin Event Details page - checks if this user can edit the single event, this can be used for CRUD
/// </summary>
/// <param name="userId"></param>
/// <param name="hasClaim"></param>
/// <param name="id"></param>
/// <returns></returns>
public EventDetailsViewModel GetUserEventDetails(string userId, bool hasClaim, int id)
{
var vm = new EventDetailsViewModel();
var sglEvent = _repo.Query <Event>().Include(e => e.Locations).Include(e => e.Comments).FirstOrDefault(e => e.Id == id);
if (hasClaim)
{
vm.CanEdit = true;
vm.HasClaim = hasClaim;
}
else
{
//if the event is the user's event, then user can edit, else user can only vote
if (sglEvent.ApplicationUserId == userId)
{
vm.CanEdit = true;
vm.HasClaim = hasClaim;
}
else
{
vm.CanEdit = false;
vm.HasClaim = false;
}
}
vm.Event = sglEvent;
sglEvent.Views++;
_repo.SaveChanges();
vm = convertDatesFromUtcToLocalTime(vm);
vm = DisplayUserName(vm);
return(vm); //usereventdetails or for admin
}
public ActionResult Details(int id)
{
var @event = _unitOfWork.Events.GetEvent(id);
if (@event == null)
{
return(HttpNotFound());
}
var viewModel = new EventDetailsViewModel {
Event = @event
};
if (User.Identity.IsAuthenticated)
{
var userId = User.Identity.GetUserId();
viewModel.IsAttending =
_unitOfWork.Attendances.GetAttendance(@event.Id, userId) != null;
viewModel.IsFollowing =
_unitOfWork.Followings.GetFollowing(userId, @event.ArtistId) != null;
}
return(View("Details", viewModel));
}
public EventDetailsPage(Event model = null)
{
InitializeComponent();
MainScroll.ParallaxView = HeaderView;
BindingContext = vm = new EventDetailsViewModel(model);
}
public IActionResult EventDetails(EventDetailsViewModel eventDetails)
{
eventDetails.Event = _eventRepository.GetEventById(eventDetails.EventId);
eventDetails.EventCategory = _eventCategoryRepository.GetCategoryById(eventDetails.Event.EventCategoryId);
eventDetails.EventSubCategory = _eventSubCategoryRepository.GetSubCategoryById(eventDetails.Event.EventSubCategoryId);
eventDetails.Venue = _venueRepository.GetVenueById(eventDetails.Event.VenueId);
eventDetails.Image = _imageRepository.GetImage(eventDetails.EventId);
eventDetails.Rsvp = new Rsvp {
EventId = eventDetails.EventId
};
eventDetails.Comments = _commentRepository.GetCommentsForEvent(eventDetails.EventId);
eventDetails.NewComment = new Comment {
EventId = eventDetails.EventId
};
eventDetails.RatingAverage = _ratingRepository.GetAvgRating(eventDetails.EventId);
if (eventDetails.UserLimitReached)
{
ViewData["Message"] = "Sva mjesta za ovaj događaj su popunjena.";
}
if (eventDetails.DuplicateUser)
{
ViewData["Message"] = "Već ste se prijavili za ovaj događaj.";
}
return(View(eventDetails));
}
// GET: Events/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
_logger.LogWarning($"Detalles del Evento {id} no encontrados");
return(NotFound());
}
//Event Info
var eventSelected = await _context.Events
.Include(ec => ec.EventCategory)
.Include(g => g.Group)
.FirstOrDefaultAsync(m => m.Id == id);
if (eventSelected == null)
{
_logger.LogError($"Consulta de base de datos NOK sobre el Evento {id}. No encontrado.");
return(NotFound());
}
//SignedIn User Info
bool signedInUserWillAttend = false;
var userId = User.FindFirst(ClaimTypes.NameIdentifier);
if (userId != null)
{
signedInUserWillAttend = _context.EventAttendances.Where(ea => ((ea.ApplicationUserId == userId.Value) && (ea.EventId == eventSelected.Id))).Any();
}
//List of Users Will Attend the Event
List <ApplicationUser> eventAttendeesList = await _context.EventAttendances
.Include(ea => ea.ApplicationUser)
.Where(ea => ea.EventId == id)
.Select(ea => ea.ApplicationUser)
.ToListAsync();
//List of Comments associated to the event
List <EventComment> eventComments = await _context.EventComments
.Include(ec => ec.ApplicationUser)
.Where(ec => ec.EventId == id)
.ToListAsync();
EventDetailsViewModel eventInfo = new EventDetailsViewModel {
EventInfo = eventSelected,
SignedInUserWillAttend = signedInUserWillAttend,
EventAttendees = eventAttendeesList,
EventComments = eventComments
};
var dictionay = new Dictionary <string, string>();
dictionay.Add("Event Details", eventSelected.Title);
_telemetryClient.TrackEvent("UserInteraction", dictionay);
return(View(eventInfo));
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var @event = await _context.Events
.FirstOrDefaultAsync(m => m.EventId == id);
if (@event == null)
{
return(NotFound());
}
var members = new List <string>();
@event.EventMembers = new List <EventMember>();
foreach (var item in _context.EventMembers)
{
if (item.EventId == @event.EventId)
{
members.Add(_context.Members.Find(item.MemberId).Username);
}
}
if (@event.EventMembers.Count == 0)
{
members.Add("No one is enrolled in this event yet.");
}
var retEvent = new EventDetailsViewModel
{
Id = (int)id,
Date = @event.Date,
Location = @event.Location,
Name = @event.Name,
RunningCoach = _context.Coaches.Find(@event.CoachId).Name,
CoachId = @event.CoachId,
Members = members
};
if (this.User.IsInRole("Coach"))
{
ViewData["Role"] = "Coach";
}
else if (this.User.IsInRole("Admin"))
{
ViewData["Role"] = "Admin";
}
else
{
ViewData["Role"] = "Member";
}
return(View(retEvent));
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
vm = null;
var adjust = Device.OS != TargetPlatform.Android ? 1 : -ViewModel.Sponsors.Count + 1;
ListViewSponsors.HeightRequest = ListViewSponsors.RowHeight - adjust;
}
public EventDetailsPage(Sensor i_StreamingSensor) : this()
{
Task.Factory.StartNew(() =>
{
landscapeEventDetailsPage = new LandscapeEventDetailsPage(i_StreamingSensor);
landscapeEventDetailsPage.RaiseContentViewUpdateEvent += eventsRouter;
});
eventDetailsViewModel = new EventDetailsViewModel(i_StreamingSensor);
eventDetailsViewModel.EventsRouter += eventsRouter;
initOrientationState();
}
public EventDetailsView(EventModel model)
{
InitializeComponent();
DataContext = _viewModel = new EventDetailsViewModel(model);
_viewModel.PropertyChanged += ViewModelOnPropertyChanged;
Owner = Application.Current.MainWindow;
Loaded += EventDetailsViewLoaded;
}
public EventDetailsPage(EventModel i_EventModel) : this()
{
Task.Factory.StartNew(() =>
{
landscapeEventDetailsPage = new LandscapeEventDetailsPage(i_EventModel);
landscapeEventDetailsPage.RaiseContentViewUpdateEvent += eventsRouter;
});
eventDetailsViewModel = new EventDetailsViewModel(i_EventModel, true);
eventDetailsViewModel.EventsRouter += eventsRouter;
initOrientationState();
}
public ActionResult Create()
{
EventDetailsViewModel eventDetailsViewModel = new EventDetailsViewModel();
var eventType = db.EventTypess.ToList();
eventDetailsViewModel.EventTypes = eventType;
var eventVanue = db.EventVanues.ToList();
eventDetailsViewModel.EventVanues = eventVanue;
return(View(eventDetailsViewModel));
}
public void Details_ShowsCorrectSession(int id, string title)
{
_mockSessionRepository.Setup(s => s.GetById(id)).Returns(_dummyContext.Sessions.First(s => s.SessionId == id));
//Session session = _dummyContext.Sessions.Where(s => s.SessionId == id).First();
var result = Assert.IsType <ViewResult>(_sessionController.Details(id, user1));
Tuple <FeedBackViewModel, EventDetailsViewModel> result2 = result.Model as Tuple <FeedBackViewModel, EventDetailsViewModel>;
EventDetailsViewModel eventDetailsViewModel = Assert.IsType <EventDetailsViewModel>(result2.Item2);
Session session = eventDetailsViewModel.Session;
Assert.Equal(title, session.Title);
Assert.Equal(id, session.SessionId);
}
public IActionResult Get(int id)
{
EventDTO ev = _eventService.Events(id);
EventDetailsViewModel model = _mapper.Map <EventDTO, EventDetailsViewModel>(ev);
model.Owner = _mapper.Map <ProfileDTO, UserProfilePreviewModel>(_profileService.GetById(model.OwnerUserId));
model.Visitors = _mapper.Map <List <ProfileDTO>, List <UserProfilePreviewModel> >(ev.Visitors
.Select(x => _profileService.GetById(x)).ToList());
return(Ok(model));
}
public ActionResult Get(int id)
{
var e = _eventRepo.Get(id);
if (e == null)
{
return(NotFound());
}
var viewModel = new EventDetailsViewModel(e.Id, e.Name, e.Description, e.Date, e.Price, e.AdditionalInformation);
return(Ok(viewModel));
}
public ActionResult EventDetails(int id)
{
var db = new HockeySignupsDb(Properties.Settings.Default.ConStr);
Event e = db.GetEventById(id);
IEnumerable <EventSignup> signups = db.GetEventSignups(id);
var vm = new EventDetailsViewModel
{
Event = e,
Signups = signups
};
return(View(vm));
}
public ActionResult EventDetails(int id)
{
var db = new HockeySignupsDb(_connectionString);
Event e = db.GetEventById(id);
IEnumerable <EventSignup> signups = db.GetEventSignups(id);
var vm = new EventDetailsViewModel
{
Event = e,
Signups = signups
};
return(View(vm));
}
public ActionResult Details(int id)
{
var eventt = _context.Events.Find(id);
if (eventt == null)
{
return(HttpNotFound());
}
var creator = _context.Users.SingleOrDefault(u => u.Id == eventt.EventCreatorId);
if (creator == null)
{
return(HttpNotFound());
}
var facility = _context.SportsFacilities.SingleOrDefault(sf => sf.Id == eventt.LocationId);
if (facility == null)
{
}
var sport = _context.Sports.SingleOrDefault(s => s.Id == eventt.SportId);
var isCreator = User.Identity.GetUserId() == creator.Id ? true : false;
var eventParticipants = _context.EventParticipants.Where(evp => evp.EventId == eventt.Id).ToList();
var participants = new List <ApplicationUser>();
foreach (var item in eventParticipants)
{
var participant = _context.Users.SingleOrDefault(u => u.Id == item.UserId);
if (participant != null)
{
participants.Add(participant);
}
}
var viewModel = new EventDetailsViewModel
{
Event = eventt,
EventCreator = creator,
Location = facility,
Activity = sport,
Participants = participants,
IsCreator = isCreator
};
return(View(viewModel));
}
public ActionResult EventDetails(int id)
{
var model = new EventDetailsViewModel();
var current = new EventManager().GetEventById(id);
CreateModel(model, current);
model.City = current.City;
model.Type = current.Type;
model.PersonsCategory = current.PersonsCategory;
model.Publisher = current.Publisher;
model.Publisher.Photo = new PhotoManager().GetImage(current.Publisher.Photo, Server.MapPath("~"), true);
model.Members = current.Members;
model.MayAttend = current.MayAttend;
model.NoAttend = current.NoAttend;
model.Likes = current.Likes;
model.DisLikes = current.Dislikes;
return View(model);
}
