public EventsPublicController(IEventsService eventsService, IUsersService usersService, ICitiesService citiesService, ISportCategoriesService sportCategories)
{
this.events = eventsService;
this.users = usersService;
this.cities = citiesService;
this.sportCategories = sportCategories;
}
// 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);
}
public EventsController(
IEventsService eventsService,
IEventService eventService,
IEventCategoriesService eventCategoriesService)
{
var currentRequestContext = System.Web.HttpContext.Current.ToRequestContext();
eventsService.RequestContext = currentRequestContext;
EventsService = eventsService;
eventService.RequestContext = currentRequestContext;
EventService = eventService;
eventCategoriesService.RequestContext = currentRequestContext;
EventCategoriesService = eventCategoriesService;
}
public BaseTestClass()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
this.EventsRepository = new EfDeletableEntityRepository <CalendarEvent>(new ApplicationDbContext(options.Options));
this.ConsultationsRepository = new EfDeletableEntityRepository <Consultation>(new ApplicationDbContext(options.Options));
this.DoctorsRepository = new EfDeletableEntityRepository <Doctor>(new ApplicationDbContext(options.Options));
this.UsersRepository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
this.PatientsRepository = new EfDeletableEntityRepository <Patient>(new ApplicationDbContext(options.Options));
this.PrescribtionsRepository = new EfDeletableEntityRepository <Prescription>(new ApplicationDbContext(options.Options));
this.EmailSender = new SendGridEmailSender("test");
this.EmailsService = new EmailsService(this.EmailSender);
this.DoctorsService = new DoctorsService(
this.DoctorsRepository,
this.UsersRepository,
this.EmailsService,
this.PatientsRepository);
this.PatientsService = new PatientsService(this.PatientsRepository);
this.ConsultationsService = new ConsultationsService(
this.DoctorsRepository,
this.ConsultationsRepository,
this.PatientsRepository,
this.EmailsService,
this.DoctorsService,
this.PatientsService);
this.EventsService = new EventsService(
this.EventsRepository,
this.ConsultationsRepository,
this.DoctorsService,
this.PatientsService,
this.EmailsService);
this.PrescriptionsService = new PrescriptionsService(this.PrescribtionsRepository);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="eventsService">The events service</param>
/// <param name="userSettings">The user settings</param>
public EventsController(IEventsService eventsService, EventSettings userSettings)
{
logger.Debug("Initializing Event Tracker Controller");
this.eventsService = eventsService;
this.userSettings = userSettings;
// Initialize the refresh timer
this.eventRefreshTimer = new Timer(this.RefreshEvents);
this.EventRefreshInterval = 1000;
// Initialize the start call count to 0
this.startCallCount = 0;
// Initialize the WorldEvents collection
this.InitializeWorldEvents();
// Set up handling of the event settings UseAdjustedTable property changed so that we can load the correct table when it changes
this.UserSettings.PropertyChanged += UserSettings_PropertyChanged;
logger.Info("Event Tracker Controller initialized");
}
public EndGame()
{
_kernel = GetKernel();
// initialize services
Updater = _kernel.Get <IUpdateService>();
Logger = _kernel.Get <ILoggingService>();
Data = _kernel.Get <IDataRepository>();
Events = _kernel.Get <IEventsService>();
Client = _kernel.Get <IGameClientService>();
Config = _kernel.Get <IConfigurationRepository>();
// load settings
var assembly = Assembly.GetExecutingAssembly();
var resourceName = "HDT.Plugins.EndGame.Resources.Default.ini";
Settings = new Settings(assembly.GetManifestResourceStream(resourceName), "EndGame");
// set logger name and pass object down to common
Logger.SetDumpFileName("EndGame");
UpdateLogger();
Common.Common.Log = Logger;
// main view model
_viewModel = new MainViewModel();
}
public HomeViewModel(IWeatherService weatherService, IEventsService eventsService, IRidesService ridesService, IMembersService memberService)
{
_weatherService = weatherService;
_eventsService = eventsService;
_ridesService = ridesService;
_memberService = memberService;
Data = new List <Trends>()
{
new Trends {
Age1 = "21", Age2 = "25", EntryTime = "10", AgeRange = "21-25"
},
new Trends {
Age1 = "26", Age2 = "30", EntryTime = "1", AgeRange = "26-30"
},
new Trends {
Age1 = "31", Age2 = "35", EntryTime = "2", AgeRange = "31-35"
},
new Trends {
Age1 = "36", Age2 = "40", EntryTime = "3", AgeRange = "36-40"
},
new Trends {
Age1 = "41", Age2 = "50", EntryTime = "5", AgeRange = ">40"
}
};
UsageData = new ObservableCollection <Usage>()
{
new Usage {
UsageType = "Happy", Percentage = "75"
},
new Usage {
UsageType = "Laughing", Percentage = "10"
},
new Usage {
UsageType = "Sad", Percentage = "15"
},
};
}
public EventDetailsPageViewModelConverter(
IUserTagService userTagService,
IFeedLinkService feedLinkService,
IEventsService <Event> eventsService,
IIntranetMemberService <IntranetMember> memberService,
ILightboxHelper lightBoxHelper,
IPermissionsService permissionsService,
IGroupHelper groupHelper,
IErrorLinksService errorLinksService,
IUBaselineRequestContext baselineRequestContext,
IGroupService groupService)
: base(errorLinksService)
{
_userTagService = userTagService;
_feedLinkService = feedLinkService;
_eventsService = eventsService;
_memberService = memberService;
_lightBoxHelper = lightBoxHelper;
_permissionsService = permissionsService;
_groupHelper = groupHelper;
_baselineRequestContext = baselineRequestContext;
_groupService = groupService;
}
public EventCreatePageViewModelConverter(
IIntranetMemberService <IntranetMember> memberService,
IPermissionsService permissionsService,
IUserTagProvider tagProvider,
IFeedLinkService feedLinkService,
IGroupMemberService groupMemberService,
IGroupHelper groupHelper,
IErrorLinksService errorLinksService,
IUBaselineRequestContext context,
IEventsService <Event> eventsService,
IGroupService groupService)
: base(errorLinksService)
{
_memberService = memberService;
_permissionsService = permissionsService;
_tagProvider = tagProvider;
_feedLinkService = feedLinkService;
_groupMemberService = groupMemberService;
_groupHelper = groupHelper;
_context = context;
_eventsService = eventsService;
_groupService = groupService;
}
void _Initialize(
[Inject] DiContainer _container,
[Inject] DisposableManager dManager,
[Inject] ISerializerService serializerService,
[Inject] IEventsService eventService)
{
if (initialized)
{
return;
}
initialized = true;
Bind();
Container = _container;
_dManager = dManager;
_eventService = eventService;
_serializerService = serializerService;
_dManager.Add(this);
AfterBind();
}
public void Test_Events_From_CacheProvider_No_Search()
{
List <Event> lsEvents1 = GetSampleEvents(10, "Cached ");
var events1 = lsEvents1.AsEnumerable();
List <Event> lsEvents2 = GetSampleEvents(10, "Cached ");
var events2 = lsEvents2.AsEnumerable();
mockCacheProvider = new Mock <ICacheProvider>();
mockCacheProvider.Setup(p => p.TryGetValue <IEnumerable <Event> >($"CMAEventsKey_localhost_1_{DateTime.Today.ToString("yyyyMMdd")}", out events1)).Returns(true);
mockCacheProvider.Setup(p => p.TryGetValue <IEnumerable <Event> >($"CMAEventsKey_localhost_2_{DateTime.Today.ToString("yyyyMMdd")}", out events2)).Returns(true);
mockEventsRepository = new Mock <IEventsRepository>();
eventsService = new EventsService(mockCacheProvider.Object, mockOptions.Object, mockEventsRepository.Object);
var resultEvents = eventsService.GetEvents(new List <int>()
{
1, 2
}, "http://localhost/", "", DateTime.Today, DateTime.Today.AddMonths(12));
Assert.NotNull(resultEvents);
Assert.Equal(20, resultEvents.Count());
}
void _Initialize(
[Inject] DiContainer _container,
[Inject] DisposableManager dManager,
[Inject] ISerializerService serializerService,
[Inject] IEventsService eventService)
{
if (initialized)
{
return;
}
initialized = true;
Bind(delayAfterBind);
if (bindAllListener != null)
{
bindAllListener.Dispose();
}
bindAllListener = null;
Container = _container;
_dManager = dManager;
_eventService = eventService;
_serializerService = serializerService;
_dManager.Add(this);
OnAfterBind.Execute();
if (!delayAfterBind)
{
AfterBind();
}
else
{
Observable.NextFrame().Subscribe(e => AfterBind()).AddTo(this);
}
}
private void _Initialize(
[Inject] DiContainer container,
[Inject] IEventsService eventService,
[Inject] DisposableManager dManager
)
{
if (initialized == true)
{
return;
}
initialized = true;
PreBind();
Container = container;
_dManager = dManager;
_eventService = eventService;
_dManager.Add(this);
this.ModelProperty.DistinctUntilChanged().Subscribe(e => ListenToModelDispose()).AddTo(this);
AfterBind();
}
public void SetUp()
{
//Mock => AppDbContext
var options = new DbContextOptionsBuilder <AppDbContext>().Options;
_dbContextMock = new Mock <AppDbContext>(options);
//Mock => AutoMapper
_autoMapperMock = new Mock <IMapper>();
//Mock => Localizer
var stringLocalizerMock = new Mock <IStringLocalizer <IEventsService> >();
stringLocalizerMock.Setup(p => p[It.IsAny <string>()]).Returns(new LocalizedString("Test", "Test String"));
//Mock => EmployeeService
_employeeService = new Mock <IEmployeeService>();
//Get Services Collection
var services = new ServiceCollection();
//Add the neccessary services to instatiate and test the SignUpService
services.AddSingleton(_dbContextMock.Object);
services.AddSingleton(_autoMapperMock.Object);
services.AddSingleton(stringLocalizerMock.Object);
services.AddSingleton(_employeeService.Object);
//Add SignUpService
services.AddTransient <IEventsService, EventsService>();
//Build the Service Provider
var serviceProvider = services.BuildServiceProvider();
//Set the _signUpService
_eventsService = serviceProvider.GetRequiredService <IEventsService>();
}
public void Dispose()
{
if (wasDisposed || Kernel.applicationQuitting)
{
return;
}
wasDisposed = true;
OnDispose();
//Tell subscribers that controller is disposing
OnDisposing.Execute();
OnDisposing.Dispose();
OnDisposing = null;
Disposables.Dispose();
DisposablesProperty.Dispose();
DisposablesProperty = null;
controllerEventsSubject.Dispose();
controllerEventsSubject = null;
viewEventsSubject.Dispose();
viewEventsSubject = null;
if (disposeModel && Model != null)
{
Model.Dispose();
}
Model = null;
Container = null;
_eventService = null;
_dManager = null;
ModelProperty.Dispose();
ModelProperty = null;
}
public EventsApiController(IUserService service, IEventsService ieService)
{
this._userService = service;
this._eventsService = ieService;
}
public SearchController(UserManager<User> userManager, IArticlesService articles, IEventsService events)
{
this.userManager = userManager;
this.articles = articles;
this.events = events;
}
public CreateAccountHandler(IEventsService <Customer, Guid> customerEventsService, IEventsService <Account, Guid> accountEventsService)
{
_customerEventsService = customerEventsService;
_accountEventsService = accountEventsService;
}
public EventsController(IEventsService eventService) => _eventService = eventService;
public ChatHub(IChatService chatService, UserManager <ApplicationUser> userManager, IEventsService eventsService)
{
this.chatService = chatService;
this.userManager = userManager;
this.eventsService = eventsService;
}
public TownsController(ITownsService townsService, IStreetsService streetsService, ICategoriesService categoriesService, IEventsService eventService)
{
this.townsService = townsService ?? throw new ArgumentNullException(nameof(townsService));
this.streetsService = streetsService ?? throw new ArgumentNullException(nameof(streetsService));
this.categoriesService = categoriesService ?? throw new ArgumentNullException(nameof(categoriesService));
this.eventsService = eventService ?? throw new ArgumentNullException(nameof(eventService));
}
public FavoriteEventsController(IUsersService usersService, IEventsService eventsService)
{
this.users = usersService;
this.events = eventsService;
}
public OrgsController(IEventsService events, IMapper mapper)
{
Events = events;
Mapper = mapper;
}
public EventsController(IEventsService eventsService, ILogger <EventsController> logger)
{
this.logger = logger;
this.eventsService = eventsService;
}
public EventsController(IEventsService events, UserManager<User> userManager)
{
this.events = events;
this.userManager = userManager;
}
public CalendarController(DataContext context)
{
_eventsService = new EventsService(context);
_manager = new UserManager(new UserStore(context));
}
public AdminEventsController(IEventsService events)
{
this.events = events;
}
public HomeController(IEventsService eventsService)
{
this.eventsService = eventsService;
}
public FilteredResults(UserManager <ApplicationUser> userManager, IEventsService eventService)
{
this.userManager = userManager;
this.eventService = eventService;
}
public CategoriesController( ICategoriesService categories, IProfilesService profiles, IEventsService events)
{
this.categories = categories;
this.profiles = profiles;
this.events = events;
}
public DeactivateAccountCommandHandler(ICurrentUserService currentUserService, IEventsService <Account, Guid> eventsService)
{
_currentUserService = currentUserService;
_eventsService = eventsService;
}
public HomeViewModel(IWeatherService weatherService, IEventsService eventsService, IRidesService ridesService)
{
_weatherService = weatherService;
_eventsService = eventsService;
_ridesService = ridesService;
}
public EventsController(IEventsService eventsService, UserManager <ApplicationUser> userManager)
{
this.eventsService = eventsService;
this.userManager = userManager;
}
public EventsController(IEventsService eventsService, ICloudinaryService cloudinaryService)
{
this.eventsService = eventsService;
this.cloudinaryService = cloudinaryService;
}
public EventsController(IEventsService eventsService)
{
this.eventsService = eventsService;
}
public HomeController(IEventsService events, IArticlesService articles)
{
this.events = events;
this.articles = articles;
}
public Task Invoke(HttpContext httpContext, RoleManager <IdentityRole> roleManager, IEventsService eventsService)
{
/* this.eventsService = eventsService;
*
* for (int index = 0; index < 100; index++)
* {
* Event @event = new Event
* {
* Id= Guid.NewGuid().ToString(),
* Name = $"Event_Number_{index}",
* Start = DateTime.UtcNow,
* End = DateTime.UtcNow.AddDays(2),
* Place = "Sofia",
* TotalTickets = 23,
* PricePerTicket = 12
* };
*
* this.eventsService.AddEvent(@event, httpContext.User);
* }*/
Seeder.SeedRoles(roleManager).Wait();
return(next(httpContext));
}
public AddEventController(IEventsService events, ICategoriesService categories)
{
this.events = events;
this.categories = categories;
}
public OrdersService(EventuresDbContext dbContext, IEventsService eventsService)
{
this.dbContext = dbContext;
this.eventsService = eventsService;
}
public EventsController(IEventsService service)
{
eventService = service;
}
public CartController(IIdentityService <ApplicationUser> identityService, ICartService cartService, IEventsService eventService)
{
_identityService = identityService;
_cartService = cartService;
_eventService = eventService;
}
public EventController(IEventsService eventService)
{
this.eventService = eventService;
}
public OrdersController(IOrderService orderService, IEventsService eventsService, UserManager <User> userManager)
{
this.orderService = orderService;
this.eventsService = eventsService;
this.userManager = userManager;
}
public EventsController(IEventsService eventsService, IZoneService zoneService, IPlayerService playerService, EventsUserData userData)
{
logger.Debug("Initializing Event Tracker Controller");
this.eventsService = eventsService;
this.zoneService = zoneService;
this.playerService = playerService;
this.isStopped = false;
this.userData = userData;
// Initialize the refresh timer
this.eventRefreshTimer = new Timer(this.RefreshEvents);
this.EventRefreshInterval = 1000;
// Initialize the start call count to 0
this.startCallCount = 0;
// Set up handling of the event settings UseAdjustedTable property changed so that we can load the correct table when it changes
this.UserData.PropertyChanged += UserData_PropertyChanged;
// Initialize the WorldEvents collection
this.InitializeWorldEvents();
// Do this on a background thread since it takes awhile
Task.Factory.StartNew(this.InitializeWorldEventZoneNames);
logger.Info("Event Tracker Controller initialized");
}
public RenameStoreGroupHandler(IEventsService <StoreGroup, Guid> storeGroupEventsService)
{
this.storeGroupEventsService = storeGroupEventsService;
}
//public EventsController()
//{
// this.repo = new EventRepository();
//}
public EventsController(IEventsService repo)
{
this.eventService = repo;
}
