public EventsPage()
{
InitializeComponent();
BindingContext = new EventsViewModel(Navigation);
if (Device.OS == TargetPlatform.Windows || Device.OS == TargetPlatform.WinPhone)
{
ToolbarItems.Add(new ToolbarItem
{
Text = "Refresh",
Icon = "toolbar_refresh.png",
Command = ViewModel.ForceRefreshCommand
});
}
ListViewEvents.ItemTapped += (sender, e) => ListViewEvents.SelectedItem = null;
ListViewEvents.ItemSelected += async(sender, e) =>
{
var ev = ListViewEvents.SelectedItem as FeaturedEvent;
if (ev == null)
{
return;
}
var eventDetails = new EventDetailsPage();
eventDetails.Event = ev;
App.Logger.TrackPage(AppPage.Event.ToString(), ev.Title);
await NavigationService.PushAsync(Navigation, eventDetails);
ListViewEvents.SelectedItem = null;
};
}
public virtual ActionResult Index()
{
var events = (from e in db.Get <Event>()
orderby e.StartDate
select e).ToList();
EventsViewModel model = new EventsViewModel()
{
Events = (from e in events
select new EventModel()
{
Id = e.Id.ToString(),
Name = e.Name,
Title = e.Title,
StartDate = e.StartDateLocal.ToWebDateTime(),
StartDateUTC = e.StartDate.ToWebDateTimeUTC(),
EndDate = e.EndDateLocal.ToWebDateTime(),
EndDateUTC = e.EndDate.ToWebDateTimeUTC(),
GoLiveDate = e.ApplicationConfig.GoLiveDateLocal.ToWebDateTime(),
GoLiveDateUTC = e.ApplicationConfig.GoLiveDate.ToWebDateTimeUTC(),
MoodPromptCount = e.MoodPrompts.Count(),
PushNotificationCount = e.PushNotifications.Count(),
IndependentActivityCount = e.IndependentActivities.Count(),
TimeZone = e.ApplicationConfig.TimeZone
}).ToList()
};
return(View(MVC.Home.Views.HomeIndex, model));
}
public ActionResult Attending()
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var events = _context.Attendances
.Where(a => a.AttendeeId == userId)
.Select(a => a.Event)
.Include(p => p.Type)
.Include(p => p.Coach)
.ToList();
var attendances = _context.Attendances.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
var vm = new EventsViewModel
{
UpcomingEvents = events,
ShowActions = User.Identity.IsAuthenticated,
Heading = "Events I'm Attending",
Attendances = attendances
};
return(View("Events", vm));
}
public async Task <IActionResult> PostEvents([FromBody] EventsViewModel events)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string filename = "";
if (events.Image != null && events.Image.Length > 0)
{
filename = events.Image.FileName;
UploadFile(events.Image, filename);
}
var row = _context.Events.Where(x => x.UserId == events.UserId).FirstOrDefault();
if (row == null)
{
row = new Events {
Date = events.Date, Description = events.Description, Title = events.Title, UserId = events.UserId, Image = filename, IsPrivate = events.IsPrivate
};
_context.Events.Add(row);
}
else
{
row.Date = events.Date;
row.Description = events.Description;
row.Title = events.Title;
row.Image = filename;
row.IsPrivate = events.IsPrivate;
}
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEvents", new { id = events.Id }, events));
}
public async Task <ViewResult> ApplyFilters([FromForm] int physicianId, [FromForm] int patientId)
{
EventsViewModel eventsViewModel = new EventsViewModel
{
Resources = new AvailableResources
{
Patients = await GetAllPatientsAsync(),
Physicians = await GetAllPhysiciansAsync()
},
Events = await GetEventsAsync(physicianId, patientId),
Filters = new GlobalFilters()
};
if (physicianId != 0)
{
eventsViewModel.Filters.PhysiciansFilters
.Add(GetPhysicianFullNameById(eventsViewModel.Resources.Physicians, physicianId));
}
if (patientId != 0)
{
eventsViewModel.Filters.PatientsFilters.
Add(GetPatientFullNameById(eventsViewModel.Resources.Patients, patientId));
}
return(View(nameof(Receptionist), eventsViewModel));
}
// GET: Events/Details/5
public ActionResult Details(int id)
{
var evnt = _context.Events
.Include(u => u.Organizer)
.Include(u => u.Category)
.SingleOrDefault(g => g.Id == id);
if (evnt == null)
{
return(HttpNotFound());
}
var viewModel = new EventsViewModel {
Event = evnt
};
if (User.Identity.IsAuthenticated)
{
var userId = User.Identity.GetUserId();
viewModel.IsAttending = _context.Attendances
.Any(a => a.EventId == evnt.Id && a.AttendeeId == userId);
viewModel.IsFollowing = _context.Followings
.Any(f => f.FolloweeId == evnt.OrganizerId && f.FolloweeId == userId);
}
return(View("Details", viewModel));
}
private void RefreshEventsForElement(ElementSave selectedElement)
{
EventsViewModel viewModel = new EventsViewModel();
viewModel.InstanceSave = null;
viewModel.ElementSave = selectedElement;
mEventsDataGrid.Instance = viewModel;
mEventsDataGrid.MembersToIgnore.Add("InstanceSave");
mEventsDataGrid.MembersToIgnore.Add("ElementSave");
mEventsDataGrid.Categories[0].Name = "Events on this";
MemberCategory exposed = new MemberCategory();
exposed.Name = "Exposed";
var exposedEvents = SelectedState.Self.SelectedElement.Events.Where(item => !string.IsNullOrEmpty(item.ExposedAsName));
foreach (var eventSave in exposedEvents)
{
EventInstanceMember instanceMember = new EventInstanceMember(
SelectedState.Self.SelectedElement,
SelectedState.Self.SelectedInstance,
eventSave);
var local = eventSave;
instanceMember.ContextMenuEvents.Add(
"Rename",
delegate
{
TextInputWindow tiw = new TextInputWindow();
tiw.Message = "Enter new name";
tiw.Result = local.ExposedAsName;
if (tiw.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
bool isValid = true;
// todo:
//string whyNotValid = null;
//isValid = NameVerifier.Self.IsEventNameValid(tiw.Result, out whyNotValid);
if (isValid)
{
string oldName = local.ExposedAsName;
local.ExposedAsName = tiw.Result;
RenameManager.Self.HandleRename(selectedElement, local, oldName);
GumCommands.Self.FileCommands.TryAutoSaveCurrentElement();
GumCommands.Self.GuiCommands.RefreshPropertyGrid();
}
}
});
exposed.Members.Add(instanceMember);
}
mEventsDataGrid.Categories.Add(exposed);
}
private void HandleItemSelect(TreeNode selectedTreeNode)
{
bool shouldShow = selectedTreeNode.IsRootEventsNode();
if (shouldShow)
{
EventsViewModel evm = new EventsViewModel();
evm.BackingElement = GlueState.Self.CurrentElement;
mEventItemList.DataContext = evm;
if (!mContainer.Controls.Contains(mTab))
{
mContainer.Controls.Add(mTab);
mContainer.SelectTab(mContainer.Controls.Count - 1);
}
}
else if (mContainer.Controls.Contains(mTab))
{
mContainer.Controls.Remove(mTab);
}
}
public ActionResult Index(string query = null)
{
var upcommingEvents = _context.Events
.Include(e => e.Organizer)
.Include(e => e.Category)
.Where(e => e.DateTime > DateTime.Now);
if (!string.IsNullOrWhiteSpace(query))
{
upcommingEvents = upcommingEvents.Where(g =>
g.Organizer.Name.Contains(query) ||
g.Category.Name.Contains(query) ||
g.Vanue.Contains(query) ||
g.Name.Contains(query));
}
var userId = User.Identity.GetUserId();
var attendances = _context.Attendances
.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
var viewModel = new EventsViewModel
{
UpcommingEvents = upcommingEvents,
ShowingActions = User.Identity.IsAuthenticated,
Heading = "Show Upcomming Events",
SearchTerm = query,
Attendances = attendances
};
return(View("index", viewModel));
}
/// <summary>
/// Executes once LoadRequest has executed. Will also happen when deserializing cached data
/// </summary>
public override object Deserialize(DayLoadContext loadContext, Type objectType, Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
string html = PageParser.GetHtml(stream);
var entries = PageParser.ExtractEntriesFromHtml(html, false);
var viewModel = new EventsViewModel(loadContext);
if (loadContext.ReverseOrder)
{
entries.Reverse();
}
var groupings = entries.GroupBy(PageParser.GroupByYear());
foreach (IGrouping<string, Entry> grouping in groupings)
{
var displayGroup = new GroupedEntries
{
Name = grouping.Key,
Entries = grouping.ToList()
};
viewModel.Events.Add(displayGroup);
}
return viewModel;
}
public IActionResult PastEvents()
{
var user = LoggedUser;
var displayEventVms = _db.Events
.Include(e => e.Address)
.Include(e => e.Organizer)
.AsNoTracking()
.Where(e => e.Date < DateTime.Now.AddHours(8) && e.Organizer == user)
.OrderByDescending(e => e.Date)
.Select(e => CreateEventViewModelForDisplaying(e))
.ToList();
var moneyCollectedOnEvent = _db.VolunteersOnEvent
.GroupBy(voe => voe.EventId)
.Select(group => new {
EventId = group.Key,
MoneyCollected = group.Sum(g => g.AmountOfMoneyCollected)
}).ToDictionary(k => k.EventId, v => v.MoneyCollected);
displayEventVms.ForEach(dvm =>
dvm.CollectedMoney = moneyCollectedOnEvent.ContainsKey(dvm.EventId) ? moneyCollectedOnEvent[dvm.EventId] : 0
);
var vm = new EventsViewModel
{
EventViewModels = displayEventVms,
ViewType = PanelViewType.ARCHIVED_EVENTS
};
return(View("EventsList", vm));
}
public IActionResult Index(string query = null)
{
var upcomingEvents = _context.Events
.Include(c => c.Coach)
.Include(c => c.Type)
.Where(p => p.DateTime > DateTime.Now && !p.IsCanceled);
if (!String.IsNullOrWhiteSpace(query))
{
upcomingEvents = upcomingEvents.Where(g =>
g.Coach.Name.Contains(query) ||
g.Type.Name.Contains(query) ||
g.Venue.Contains(query));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var attendances = _context.Attendances.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
; var vm = new EventsViewModel
{
UpcomingEvents = upcomingEvents.ToList(),
ShowActions = User.Identity.IsAuthenticated,
Heading = "Upcoming Events ", //My upcoming events on the other screen SearchTerm = query
SearchTerm = query,
Attendances = attendances
};
return(View("Events", vm));
}
//// GET: Partial
public ActionResult Events()
{
EventsViewModel _model = new EventsViewModel();
_model.Events = db.Contents.ToList().Where(x => x.Type.name == "Event").OrderByDescending(x => x.publish_date).Take(4);
return(PartialView(_model));
}
public ActionResult Attending()
{
var userId = User.Identity.GetUserId();
var gigs = _context.Attendances
.Where(a => a.AttendeeId == userId)
.Select(a => a.Event)
.Include(g => g.Category)
.Include(g => g.Organizer)
.ToList();
var attendances = _context.Attendances
.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
var viewModel = new EventsViewModel
{
UpcommingEvents = gigs,
ShowingActions = User.Identity.IsAuthenticated,
Heading = "My Attending Events",
Attendances = attendances
};
return(View("Events", viewModel));
}
public async Task <IActionResult> EventEdit(EventsViewModel mod)
{
db.Eventsees.Update(mod);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IEnumerable <dynamic> > Update([FromBody] EventsViewModel evm)
{
string sql = "";
using (var conn = util.MasterCon())
{
try
{
return(await(conn.QueryAsync <dynamic>(sql, new
{
evm.id,
evm.monitorId,
evm.time,
evm.level,
evm.featureName,
evm.value,
evm.threshold,
evm.status,
evm.description,
evm.featureCode,
evm.warningLimit,
evm.cautionLimit,
evm.count
}, commandType: CommandType.StoredProcedure)));
}
catch (Exception ex)
{
throw new CustomException("Unable to Save Or Update, Please Contact Support!!!", "Error", true, ex);
}
}
}
public async Task <ObservableCollection <EventsViewModel> > GetWindowsEvents(string key)
{
var eventsView = new ObservableCollection <EventsViewModel>();
var windowsEventsInfo = await _webservice.GetUlsViewerStatusAsync(key);
var windowsEvents = windowsEventsInfo.ToArray();
Color color = Color.FromRgb(99, 255, 74);
var groups = windowsEvents.GroupBy(x => x.Level).Select(grp => grp.ToList()).ToList();
int amount = 0;
int errors = 0;
foreach (var g in groups)
{
var last = g.Last();
if (last.Level == "Error")
{
errors = g.Count();
amount += errors;
}
}
if (errors != 0)
{
color = Color.FromRgb(222, 97, 0);
}
EventsViewModel uvm = new EventsViewModel(color, amount.ToString(), key);
eventsView.Add(uvm);
return(eventsView);
}
public IActionResult Index(string query = null)
{
var upcomingEvents = _context.Events
.Include(c => c.Coach)
.Include(c => c.Type)
.Where(p => p.DateTime > DateTime.Now && !p.IsCanceled);
if (!String.IsNullOrWhiteSpace(query))
{
upcomingEvents = upcomingEvents.Where(g =>
g.Coach.Name.Contains(query) ||
g.Type.Name.Contains(query) ||
g.Venue.Contains(query));
}
var vm = new EventsViewModel
{
UpcomingEvents = upcomingEvents.ToList(),
ShowActions = User.Identity.IsAuthenticated,
Heading = "Upcoming Events ", //My upcoming events on the other screen SearchTerm = query
SearchTerm = query
};
return(View("Events", vm));
}
public IActionResult Index()
{
var allEvents = _eventService.GetAll();
var model = new EventsViewModel()
{
Events = allEvents.Select(result => new EventInfoViewModel
{
Id = result.Id,
DateAdded = result.DateAdded,
DateHappens = result.DateHappens,
Description = result.Description,
EventType = result.EventTypeId.ToString("G"),
AllEventTypes = _eventService.GetAllEventTypes(),
Location = result.Location,
MaxGuestsCount = result.MaxGuestsCount,
Name = result.Name,
ListOfGuests = result.ListOfGuests.Select(g => new GuestInfoViewModel()
{
Id = g.Id,
Email = g.Email,
FirstName = g.FirstName,
LastName = g.LastName,
Patronymic = g.Patronymic,
Comment = g.Comment,
})
})
};
return(View(model));
}
public ViewResult List(int?categoryId, int?subcategoryId)
{
if (subcategoryId.HasValue)
{
EventsViewModel model = new EventsViewModel
{
Events = _repository.EventsAsync(null, subcategoryId)
};
return(View(model));
}
else if (categoryId == null)
{
EventsViewModel model = new EventsViewModel
{
Events = _repository.EventsAsync(null, null)
};
return(View(model));
}
else
{
EventsViewModel model = new EventsViewModel
{
Events = _repository.EventsAsync(categoryId, null)
};
return(View(model));
}
}
public async Task <ActionResult> UpdateEvent(int id, [FromBody] EventsViewModel eventupd)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
Events dalevent = new Events();
Mapper.Map <EventsViewModel, Events>(eventupd, dalevent);
var status = await _unitOfWork.EventsRepository.UpdateEvent(dalevent);
if (!status)
{
return(BadRequest());
}
return(Ok());
}
catch (Exception exp)
{
_logger.LogError(exp.Message);
return(BadRequest());
}
}
public ActionResult Index(string query = null)
{
var upcomingEvents = _context.Events
.Include(e => e.Instructor)
.Include(e => e.EventType)
.Where(e => e.DateTime > DateTime.Now && !e.IsCanceled);
if (!string.IsNullOrWhiteSpace(query))
{
upcomingEvents = upcomingEvents
.Where(e =>
e.Instructor.Name.Contains(query) ||
e.EventType.Name.Contains(query));
}
var userId = User.Identity.GetUserId();
var attendances = _context.Attendances
.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
var viewModel = new EventsViewModel
{
UpcomingEvents = upcomingEvents,
ShowActions = User.Identity.IsAuthenticated,
Heading = "Upcoming Events",
SearchTerm = query,
Attendances = attendances
};
return(View("Events", viewModel));
}
/// <summary>
/// Executes once LoadRequest has executed. Will also happen when deserializing cached data
/// </summary>
public override object Deserialize(DayLoadContext loadContext, Type objectType, Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
string html = PageParser.GetHtml(stream);
var entries = PageParser.ExtractEntriesFromHtml(html, false);
var viewModel = new EventsViewModel(loadContext);
if (loadContext.ReverseOrder)
{
entries.Reverse();
}
var groupings = entries.GroupBy(PageParser.GroupByYear());
foreach (IGrouping <string, Entry> grouping in groupings)
{
var displayGroup = new GroupedEntries
{
Name = grouping.Key,
Entries = grouping.ToList()
};
viewModel.Events.Add(displayGroup);
}
return(viewModel);
}
public ActionResult Edit(EventsViewModel EVM)
{
EventQuery Equery = new EventQuery();
EventDTO Edto = new EventDTO();
Edto.Id = EVM.Id;
Edto.Name = EVM.Name;
Edto.Address = EVM.Address;
Edto.City = EVM.City;
Edto.State = EVM.State;
Edto.Zip = EVM.Zip;
Edto.Detail = EVM.Detail;
Edto.Categories = EVM.Categories;
Edto.Description = EVM.Description;
Edto.Logo = EVM.Logo;
Edto.TicketPrice = EVM.TicketPrice;
Edto.TimeStart = EVM.TimeStart;
Edto.TimeStop = EVM.TimeStop;
Edto.HashTag = EVM.HashTag;
Edto.TwitterHandle = EVM.TwitterHandle;
Edto.Web = EVM.Web;
Edto.AttendeeCap = EVM.AttendeeCap;
Equery.EditEvent(Edto);
return(RedirectToAction("Index"));
}
public ActionResult Attending()
{
var userId = User.Identity.GetUserId();
var events = _context.Attendances
.Where(a => a.AttendeeId == userId)
.Select(a => a.Event)
.Include(e => e.Instructor)
.Include(e => e.EventType)
.ToList();
var attendances = _context.Attendances
.Where(a => a.AttendeeId == userId && a.Event.DateTime > DateTime.Now)
.ToList()
.ToLookup(a => a.EventId);
var viewModel = new EventsViewModel()
{
UpcomingEvents = events,
ShowActions = User.Identity.IsAuthenticated,
Heading = "Events I'm Attending",
Attendances = attendances
};
return(View("Events", viewModel));
}
public ActionResult Edit(int id)
{
var model = _context.Events.SingleOrDefault(cu => cu.Id == id);
if (model == null)
{
return(HttpNotFound());
}
var vCashList = _context.VodafoneCashs.Where(v => v.Event_ID == model.Id).Select(vc => vc.Number).ToList();
var eCashList = _context.EtisalatCashs.Where(et => et.Event_ID == model.Id).Select(ee => ee.Number).ToList();
var viewModel = new EventsViewModel
{
Id = model.Id,
Name = model.Name,
Prize_1 = model.Prize_1,
Prize_2 = model.Prize_2,
Prize_3 = model.Prize_3,
Host_1 = model.Host_1,
Host_2 = model.Host_2,
Host_3 = model.Host_3,
//Date = model.Date.Date,
//Time = model.Time,
Entry_Fees = model.Entry_Fees,
No_Of_Players = model.No_Of_Players,
Type = model.Type,
Match_Duration = model.Match_Duration,
Address = model.Address,
Location_URL = model.Location_URL,
EtisalatCashNumbers = eCashList,
VodafoneCashNumbers = vCashList
};
return(View("New", viewModel));
}
public ActionResult Create([Bind(Include = "Name,Address,City,State,Zip,Web,TwitterHandle,TimeStart,TimeStop,Description,Detail,TicketPrice,HashTag,AttendeeCap")] EventsViewModel eventsViewModel)
{
EventDTO Edto = new EventDTO();
EventQuery Equery = new EventQuery();
//ModelState.Remove("CreatedBy");
if (ModelState.IsValid)
{
//db.Events.Add(events);
//db.SaveChanges();
Edto.Name = eventsViewModel.Name;
Edto.Address = eventsViewModel.Address;
Edto.City = eventsViewModel.City;
Edto.State = eventsViewModel.State;
Edto.Zip = eventsViewModel.Zip;
Edto.Web = eventsViewModel.Web;
Edto.TwitterHandle = eventsViewModel.TwitterHandle;
Edto.TimeStart = eventsViewModel.TimeStart;
Edto.TimeStop = eventsViewModel.TimeStop;
Edto.Description = eventsViewModel.Description;
Edto.Detail = eventsViewModel.Detail;
Edto.TicketPrice = eventsViewModel.TicketPrice;
Edto.HashTag = eventsViewModel.HashTag;
Edto.AttendeeCap = eventsViewModel.AttendeeCap;
Equery.CreateEvent(Edto);
return(RedirectToAction("Index"));
}
return(View(eventsViewModel));
}
public IActionResult Details(int id)
{
string url = String.Concat(API_BASE_URL, id);
EventsViewModel techTalk = null;
try
{
var client = new WebClient();
var response = client.DownloadString(url);
Console.WriteLine($"Data returned from API call : {response}");
techTalk = JsonConvert.DeserializeObject <EventsViewModel>(response);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
if (techTalk != null)
{
return(View(techTalk));
}
else
{
return(NotFound());
}
}
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 <ActionResult> Post([FromBody] EventsViewModel Eventpost)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Events dalevent = new Events();
//dalevent.title = Eventpost.title;
//dalevent.description = Eventpost.description;
//dalevent.sid = Eventpost.sid;
//dalevent.eventdateu = DateTime.Now.ToString();
//dalevent.startTime = Eventpost.startTime;
//dalevent.endTime = Eventpost.endTime;
//dalevent.primaryColor = "#ad2121";
//dalevent.secondaryColor = "#FAE3E3";
//dalevent.location = Eventpost.location;
//dalevent.draggable = Eventpost.draggable;
bool insnewEvent = await _unitOfWork.EventsRepository.InsertEvent(dalevent);
if (insnewEvent == false)
{
return(BadRequest("Itsnull"));
}
return(Ok());
}
public async Task <IActionResult> CreateEvent(EventsViewModel eventView)
{
if (ModelState.IsValid)
{
var eventDto = new EventDTO
{
Name = eventView.Name,
CategoryId = eventView.CategoryId,
DateTime = eventView.Date,
VenueId = eventView.VenueId,
Description = eventView.Description,
Banner = eventView.Banner
};
var operationDetails = await _action.Create(eventDto);
if (operationDetails.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
return(View());
}
}
return(NotFound());
}
// GET: Event
public ActionResult Index()
{
List <Event> list = uow.EventRepository.GetAll();
EventsViewModel model = new EventsViewModel(list);
return(View(model));
}
// GET: Events
public ActionResult Index(string searchString)
{
var events = this.events.GetAll().To<DetailsEventViewModel>();
if (!String.IsNullOrEmpty(searchString))
{
events = events.Where(s => s.Name.ToLower().Contains(searchString.ToLower()));
}
var viewModel = new EventsViewModel
{
Events = events,
};
return this.View(viewModel);
}
/// <summary>
/// Provides a deterministic way to create the EventsViewModelPropertyName property.
/// </summary>
public static void CreateEventsViewModelPropertyName()
{
if (_eventsViewModel == null)
_eventsViewModel = new EventsViewModel(_service);
}
/// <summary>
/// Provides a deterministic way to delete the EventsViewModelPropertyName property.
/// </summary>
public static void ClearEventsViewModelPropertyName()
{
_eventsViewModel.Cleanup();
_eventsViewModel = null;
}
public void Init()
{
//var viewModel = IoC.GetAllInstances(typeof(IBookmark)).FirstOrDefault() as IBookmark;
Menu = new CircularMenuItem
{
Id = "Events",
Title = "test",
Icon = "pack://*****:*****@"icons\layers.png";
AppState.AddStartPanelTabItem(spti);
}
