public async Task <IActionResult> Index()
{
var currentUser = await _userManager.GetUserAsync(User);
var userEventIds = await _dbContext.EventMembers
.Where(x => x.UserId == currentUser.Id)
.Select(x => x.EventId)
.ToListAsync();
var events = await _dbContext.Events.Include(x => x.Members)
.Where(x => !x.HideFromPublicLists ||
(userEventIds.Contains(x.Id) ||
x.OwnerUserId == currentUser.Id))
.OrderBy(x => x.StartOn)
.ThenBy(x => x.EndOn)
.ProjectTo <EventModel>()
.ToListAsync();
var model = new EventListViewModel
{
Events = events
};
return(View(model));
}
//private int _pageSize = 15;//500;
//
// GET: /Event/
public ActionResult Index(int?pageUpcoming, int?pageRecent)
{
var currentPageUpcoming = pageUpcoming ?? 1;
ViewData["CurrentPageUpcoming"] = currentPageUpcoming;
ViewData["PageSizeUpcoming"] = _pageSizeUpcoming;
var currentPageRecent = pageRecent ?? 1;
ViewData["CurrentPageRecent"] = currentPageRecent;
ViewData["PageSizeRecent"] = _pageSizeRecent;
bool initiateOnly = User.IsInRole("Initiate");
var upcomingViewModel = GetUpcomingEvents(true, initiateOnly);
var recentViewModel = GetUpcomingEvents(false, initiateOnly);
ViewData["TotalPagesUpcoming"] = (int)Math.Ceiling((float)upcomingViewModel.Count() / _pageSizeUpcoming);
ViewData["TotalPagesRecent"] = (int)Math.Ceiling((float)recentViewModel.Count() / _pageSizeRecent);
var pageViewModel = new EventListViewModel
{
UpcomingEvents = upcomingViewModel.Skip((currentPageUpcoming - 1) * _pageSizeUpcoming).Take(_pageSizeUpcoming).ToList(),
RecentEvents = recentViewModel.Skip((currentPageRecent - 1) * _pageSizeRecent).Take(_pageSizeRecent).ToList(),
};
pageViewModel.UpcomingEventsImages = GetEventImages(pageViewModel.UpcomingEvents);
pageViewModel.RecentEventsImages = GetEventImages(pageViewModel.RecentEvents);
return(View(pageViewModel));
}
public async Task <IActionResult> List()
{
ApplicationUser appUser = await _userManager.GetUserAsync(HttpContext.User);
User user = _repository.GetUser(Guid.Parse(appUser.Id));
if (user.ActiveGroup == null)
{
return(Forbid());
}
EventListViewModel model = new EventListViewModel()
{
Events = _repository.GetEvents(user.ActiveGroup.Id).Select(e => new EventViewModel()
{
Id = e.Id.ToString(),
Name = e.Name,
Text = e.Text,
Time = e.Time,
Upcoming = DateTime.Now.CompareTo(e.Time) < 0
}).ToList()
};
return(View(model));
}
public EventListView(User user)
{
InitializeComponent();
this.ViewModel = new EventListViewModel(user);
this.BindingContext = this.ViewModel;
//this.ListEvent.ItemsSource = ViewModel.Events;
}
public static EventListViewModel ToEventsListViewModel(this ListWithTotalDTO dto)
{
EventListViewModel model = null;
if (dto != null)
{
IEnumerable <EventListItemViewModel> list = new List <EventListItemViewModel>();
if (dto.List != null)
{
list = dto.List.Cast <Event>().Select(x => new EventListItemViewModel()
{
Id = x.Id.ToString(),
DateStart = x.DateStart.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff'Z'"),
DateEnd = x.DateEnd.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff'Z'"),
Location = x.Location,
Title = x.Title,
Description = x.Description
});
}
model = new EventListViewModel()
{
Total = dto.Total,
List = list
};
}
return(model);
}
public IActionResult SearchEvent(string searchText)
{
var searchViewModel = new SearchViewModel();
var allevents = new List <EventListViewModel>();
var events = _eventRepository.GetAll().ToList();
foreach (var ev in events)
{
var eventvm = new EventListViewModel();
eventvm.EventId = ev.EventId;
eventvm.Name = ev.Name;
eventvm.City = _locationRepository.Get(ev.LocationId.GetValueOrDefault())?.City;
eventvm.CategoryName = _categoryRepository.Get(ev.CategoryId.GetValueOrDefault())?.CategoryName;
eventvm.Status = ev.Status == true ? "Active" : "InActive";
eventvm.CategoryId = ev.CategoryId.GetValueOrDefault();
allevents.Add(eventvm);
}
if (string.IsNullOrEmpty(searchText))
{
searchViewModel.AllEvents = allevents;
}
else
{
var inputtxt = searchText.ToLower();
searchViewModel.AllEvents = allevents.Where(x => x.Name.ToLower() == inputtxt).ToList();
}
searchViewModel.InputText = searchText;
ViewBag.ActiveSearch = "Active";
return(View("~/Views/Event/SearchEvent.cshtml", searchViewModel));
}
public async Task <IActionResult> Index()
{
using (var client = _httpClientFactory.CreateAuthorizedClient())
{
var apiClient = new EventsClient(client);
var response = await apiClient.GetAsync();
var list = response
.Result
.Select(x => new EventListItemViewModel
{
Id = x.Id,
Authors = x.Authors,
Cast = x.Cast,
Categories = x.Categories.ToArray(),
DateTime = x.DateTime,
Description = x.Description,
Duration = x.Duration,
Title = x.Title
});
var viewModel = new EventListViewModel(list);
return(View(viewModel));
}
}
public EventListPage()
{
viewModel = new EventListViewModel();
viewModel.PropertyChanged += ViewModel_PropertyChanged;
BindingContext = viewModel;
InitializeComponent();
}
public IActionResult Index(int?id)
{
var vm = new EventsViewModel();
var events = _eventRepository.GetAll().ToList();
var allevents = new List <EventListViewModel>();
foreach (var ev in events)
{
var eventvm = new EventListViewModel();
eventvm.EventId = ev.EventId;
eventvm.Name = ev.Name;
eventvm.City = _locationRepository.Get(ev.LocationId.GetValueOrDefault())?.City;
eventvm.CategoryName = _categoryRepository.Get(ev.CategoryId.GetValueOrDefault())?.CategoryName;
eventvm.Status = ev.Status == true ? "Active" : "InActive";
eventvm.CategoryId = ev.CategoryId.GetValueOrDefault();
allevents.Add(eventvm);
}
vm.AllEvents = allevents;
vm.ActiveEvents = vm.AllEvents.Where(r => r.Status == "Active").ToList();
if (id > 0)
{
vm.ActiveEvents = vm.ActiveEvents.Where(r => r.CategoryId == id).ToList();
}
ViewBag.ActiveHome = "Active";
return(View("~/Views/Home/Index.cshtml", vm));
}
public async Task GetAllPerPageShouldFilterCorrectltyByCreatorId()
{
var creatorId = Guid.NewGuid().ToString();
var secondEventDate = DateTime.UtcNow;
await this.CreateEventAsync("First Event", DateTime.UtcNow, Guid.NewGuid().ToString());
var secondEventId = await this.CreateEventAsync("Second Event", secondEventDate, creatorId);
var secondModel = new EventListViewModel()
{
Id = secondEventId,
Name = "Second Event",
IsDeleted = false,
ActivationDateAndTime = secondEventDate,
DurationOfActivity = TimeSpan.FromMinutes(30),
Status = Status.Pending.ToString(),
};
var resultModelCollection = await this.Service.GetAllPerPage <EventListViewModel>(1, 2, creatorId);
Assert.Single(resultModelCollection);
Assert.IsAssignableFrom <IList <EventListViewModel> >(resultModelCollection);
Assert.Equal(secondModel.Id, resultModelCollection.First().Id);
Assert.Equal(secondModel.Name, resultModelCollection.First().Name);
Assert.Equal(secondModel.IsDeleted, resultModelCollection.First().IsDeleted);
Assert.Equal(secondModel.ActivationDateAndTime, resultModelCollection.First().ActivationDateAndTime);
Assert.Equal(secondModel.DurationOfActivity, resultModelCollection.First().DurationOfActivity);
Assert.Equal(secondModel.Status, resultModelCollection.First().Status);
}
//
// GET: /Events/
public ActionResult Index()
{
var viewModel = new EventListViewModel();
var vmList = viewModel.DisplayEvents();
return(View("DisplayEvents", vmList));
}
protected override void OnAppearing()
{
base.OnAppearing();
eventListViewModel = new EventListViewModel(type);
this.BindingContext = eventListViewModel;
//LoadEvents();
}
public EventListPage()
{
InitializeComponent();
BindingContext = new EventListViewModel();
NavigationPage.SetHasNavigationBar(this, true);
NavigationPage.SetHasBackButton(this, false);
}
public async Task GetAllPerPageByCreatorIdAndStatusShouldSkipCorrectly()
{
var creatorId = Guid.NewGuid().ToString();
var firstEventDate = DateTime.UtcNow;
var firstEventId = await this.CreateEventAsync("First Event", firstEventDate, creatorId);
await this.CreateEventAsync("Second Event", DateTime.UtcNow, creatorId);
var firstModel = new EventListViewModel()
{
Id = firstEventId,
Name = "First Event",
IsDeleted = false,
ActivationDateAndTime = firstEventDate,
DurationOfActivity = TimeSpan.FromMinutes(30),
Status = Status.Pending.ToString(),
};
var resultModelCollection =
await this.Service.GetAllPerPageByCreatorIdAndStatus <EventListViewModel>(2, 1, Status.Pending, creatorId);
Assert.Equal(firstModel.Id, resultModelCollection.Last().Id);
Assert.Equal(firstModel.Name, resultModelCollection.Last().Name);
Assert.Equal(firstModel.IsDeleted, resultModelCollection.Last().IsDeleted);
Assert.Equal(firstModel.ActivationDateAndTime, resultModelCollection.Last().ActivationDateAndTime);
Assert.Equal(firstModel.DurationOfActivity, resultModelCollection.Last().DurationOfActivity);
Assert.Equal(firstModel.Status, resultModelCollection.Last().Status);
}
public ActionResult Select(string category)
{
IEnumerable <Event> events = db.Events.ToList();
if (!string.IsNullOrEmpty(category) && !category.Equals("Все"))
{
events = events.Where(p => p.Category == category);
}
EventListViewModel eventsList = new EventListViewModel
{
Events = events.ToList(),
Categories = new SelectList(new List <string>()
{
"помощь",
"развлечения",
"образование",
"красота",
"спорт",
"культура",
"наука"
})
};
return(View(eventsList));
}
public EventListViewModelTest()
{
eventListViewModel = new EventListViewModel()
{
PurchaseViewModels = new ObservableCollection <PurchaseViewModel>()
{
new PurchaseViewModel(new PurchaseEvent()
{
Id = 3,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
new PurchaseViewModel(new PurchaseEvent()
{
Id = 3,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
new PurchaseViewModel(new PurchaseEvent()
{
Id = 3,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
},
ReturnViewModels = new ObservableCollection <ReturnViewModel>()
{
new ReturnViewModel(new ReturnEvent()
{
Id = 4,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
new ReturnViewModel(new ReturnEvent()
{
Id = 4,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
new ReturnViewModel(new ReturnEvent()
{
Id = 4,
ProductId = 9,
ClientId = 8,
EventDate = "22/12/20"
}),
}
};
}
public IActionResult Administrate()
{
EventListViewModel viewModel = new EventListViewModel();
viewModel.Caption = _localizer[EventStrings.EV_VIEW_CAPTION];
viewModel.Events = _eventRepository.GetAll();
return(View(viewModel));
}
public IActionResult Index()
{
EventListViewModel viewModel = new EventListViewModel()
{
Events = _eventService.GetAllAdmin()
};
return(View(viewModel));
}
public IActionResult EventList()
{
EventListViewModel viewModel = new EventListViewModel
{
Events = _eventService.GetAllWeb()
};
return(View(viewModel));
}
public EventListView()
{
InitializeComponent();
EventListViewModel _vm = (EventListViewModel)DataContext;
_vm.MessageBoxShowDelegate = text => MessageBox.Show(
text, "Error", MessageBoxButton.OK, MessageBoxImage.Information);
}
public ActionResult List()
{
var viewModel = new EventListViewModel();
var vmList = viewModel.ListEvents();
ViewData["Count"] = vmList.Count();
return(View("ListEvents", vmList));
}
public async Task <IActionResult> Index()
{
EventListViewModel model = new EventListViewModel();
var eventModel = await _accountCtx.Events.ForAccount(CommonAccount.Id).ToListAsync();
model.EventListItem = Mapper.Map <List <EventListItem> >(eventModel);
return(View(model));
}
public async Task GetPerPageByStudentIdFilteredByStatusAsyncShouldReturnCorrectModelCollection()
{
var creatorId = Guid.NewGuid().ToString();
var firstEventDate = DateTime.UtcNow;
var secondEventDate = DateTime.UtcNow;
var firstEventId = await this.CreateEventAsync("First Event", firstEventDate, creatorId);
var secondEventId = await this.CreateEventAsync("Second Event", secondEventDate, creatorId);
var studentId = Guid.NewGuid().ToString();
await this.AssignStudentToEvent(studentId, firstEventId);
await this.AssignStudentToEvent(studentId, secondEventId);
var firstModel = new EventListViewModel()
{
Id = firstEventId,
Name = "First Event",
IsDeleted = false,
ActivationDateAndTime = firstEventDate,
DurationOfActivity = TimeSpan.FromMinutes(30),
Status = Status.Pending.ToString(),
};
var secondModel = new EventListViewModel()
{
Id = secondEventId,
Name = "Second Event",
IsDeleted = false,
ActivationDateAndTime = secondEventDate,
DurationOfActivity = TimeSpan.FromMinutes(30),
Status = Status.Pending.ToString(),
};
var resultModelCollection = await this.Service.GetPerPageByStudentIdFilteredByStatusAsync <EventListViewModel>(
Status.Pending, studentId, 1, 2, false);
Assert.Equal(2, resultModelCollection.Count());
Assert.IsAssignableFrom <IList <EventListViewModel> >(resultModelCollection);
Assert.Equal(firstModel.Id, resultModelCollection.Last().Id);
Assert.Equal(firstModel.Name, resultModelCollection.Last().Name);
Assert.Equal(firstModel.IsDeleted, resultModelCollection.Last().IsDeleted);
Assert.Equal(firstModel.ActivationDateAndTime, resultModelCollection.Last().ActivationDateAndTime);
Assert.Equal(firstModel.DurationOfActivity, resultModelCollection.Last().DurationOfActivity);
Assert.Equal(firstModel.Status, resultModelCollection.Last().Status);
Assert.Equal(secondModel.Id, resultModelCollection.First().Id);
Assert.Equal(secondModel.Name, resultModelCollection.First().Name);
Assert.Equal(secondModel.IsDeleted, resultModelCollection.First().IsDeleted);
Assert.Equal(secondModel.ActivationDateAndTime, resultModelCollection.First().ActivationDateAndTime);
Assert.Equal(secondModel.DurationOfActivity, resultModelCollection.First().DurationOfActivity);
Assert.Equal(secondModel.Status, resultModelCollection.First().Status);
}
public ActionResult AllEvents()
{
var EventDTOs = EventService.GetAllEvents();
var UpcomingEvents = EventDTOs.Where(@event => @event.StartDateAndTime >= DateTime.Now).ToList();
var PastEvents = EventDTOs.Where(@event => @event.StartDateAndTime < DateTime.Now).ToList();
EventListViewModel EventListViewModel = new EventListViewModel();
EventListViewModel.PastEvents = EventMapping.EventDTOList2PartialEventList(PastEvents);
EventListViewModel.UpcomingEvents = EventMapping.EventDTOList2PartialEventList(UpcomingEvents);
return(View("Events", EventListViewModel));
}
// Laden vergangener Events
public async Task <ViewResult> History()
{
EventListViewModel viewModel = new EventListViewModel();
viewModel.Caption = _localizer[EventStrings.EV_VIEW_CAPTION];
var user = await _userManager.GetUserAsync(this.User);
viewModel.TeamNames = _teamRepository.GetForUser(user.UserId).Select(t => t.Designation).ToArray();
viewModel.Events = _eventRepository.GetHistoricalForUser(user.UserId).OrderByDescending(e => e.Start);
return(View(viewModel));
}
public new ActionResult View()
{
List <Event> events;
events = db.Events.ToList();
EventListViewModel viewModel = new EventListViewModel();
viewModel.Events = events;
// viewModel.ProductsCategory = Categories;
return(View(viewModel));
}
public ActionResult InvitedEvents()
{
UserViewModel User = (UserViewModel)Session["User"];
var EventDTOs = EventService.GetInvitedEvents(User.Email);
var UpcomingEvents = EventDTOs.Where(@event => @event.StartDateAndTime >= DateTime.Now).ToList();
var PastEvents = EventDTOs.Where(@event => @event.StartDateAndTime < DateTime.Now).ToList();
EventListViewModel EventListViewModel = new EventListViewModel();
EventListViewModel.PastEvents = EventMapping.EventDTOList2PartialEventList(PastEvents);
EventListViewModel.UpcomingEvents = EventMapping.EventDTOList2PartialEventList(UpcomingEvents);
return(View(EventListViewModel));
}
public ActionResult EventList(int?page)
{
var pageSize = 10;
var events = _event.GetEvents().ToList().ToPagedList(page ?? 1, pageSize);
var elvm = new EventListViewModel
{
Events = events
};
ViewBag.Page = page;
ViewBag.PageSize = pageSize;
return(View(elvm));
}
public async Task <ViewResult> Index()
{
EventListViewModel viewModel = new EventListViewModel();
viewModel.Caption = _localizer[EventStrings.EV_VIEW_CAPTION];
var user = await _userManager.GetUserAsync(this.User);
viewModel.TeamNames = _teamRepository.GetForUser(user.UserId).Select(t => t.Designation).ToArray();
viewModel.Events = _eventRepository.GetAllForUser(user.UserId, true);
return(View(viewModel)); // View to Show -> Render default view for this method action
// Default View: Controller will search in View-Subfolder for View with same name as the controller
// Passing Parameters to View results in a strongly typed view. Alternative: Razor / ViewBag-Property
}
public async Task <IActionResult> Index()
{
var events = await _dbContext.Events
.Select(x => ModelMapper.ToEventModel(x))
.ToListAsync();
var model = new EventListViewModel
{
Events = events
};
model.CanCreateEvent = (await _authorizationService.AuthorizeAsync(User, null, Policies.Admin)).Succeeded;
return(View(model));
}
public ContentResult Search(int page, int rows, string sidx, string sord, string filters, string searchField, string searchOper, string searchString)
{
var model = new EventListViewModel();
ContentResult result = new ContentResult()
{
Content = model.EventListGrid.Search(sidx, sord, page, rows, true, filters, searchField, searchOper, searchString),
ContentType = "application/json"
};
return result;
}
public FileStreamResult Export(string sidx, string sord, string filters)
{
var model = new EventListViewModel();
Stream fileStream = new MemoryStream(_excelService.GetExcel(model.EventListGrid, "Event", sidx, sord, filters));
HttpContext.Response.AddHeader("content-disposition", "attachment; filename=Event.xlsx");
return new FileStreamResult(fileStream, "application/ms-excel");
}
