public OrgsByCategoryController(IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper, IRegistrationService registrationService) { this.organizationService = organizationService; this.webSecurityService = securityService; this.emailHelper = emailHelper; this.registrationService = registrationService; }
public static AdminRegistrationViewModel Create(IRepository repository, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, TermCode termCode, string userId, string studentid, string lastName, string firstName, string majorCode, int? ceremonyId, string collegeCode) { Check.Require(repository != null, "Repository is required."); Check.Require(majorService != null, "Major service is required."); Check.Require(ceremonyService != null, "ceremonyService is required."); var ceremonies = ceremonyService.GetCeremonies(userId, termCode); var colleges = new List<College>(); foreach(var a in ceremonies) colleges.AddRange(a.Colleges); var viewModel = new AdminRegistrationViewModel() { MajorCodes = majorService.GetByCeremonies(userId, ceremonies), Colleges = colleges.Distinct().ToList(), Ceremonies = ceremonies, studentidFilter = studentid, lastNameFilter = lastName, firstNameFilter = firstName, majorCodeFilter = majorCode, ceremonyFilter = ceremonyId ?? -1, collegeFilter = collegeCode, Participations = registrationService.GetFilteredParticipationList(userId, studentid, lastName, firstName, majorCode, ceremonyId, collegeCode, ceremonies, termCode) }; //if (!string.IsNullOrEmpty(majorCode)) // viewModel1111 = viewModel.Registrations.Where(a => a.Student.StrMajorCodes.Contains(majorCode)); return viewModel; }
public GamingSummaryViewModel(GameController controller, IGameControlService controlService, IRegistrationService registrationService, IContestDao contestDao, IEventAggregator eventAggregator) { _controller = controller; _controlService = controlService; _registrationService = registrationService; _contestDao = contestDao; this.OpenGameSelectionCommand = _controller.OpenGameSelectionCommand; this.StartGameCommand = DelegateCommand<SequencingItem>.FromAsyncHandler(StartGame); this.MakeShotCommand = DelegateCommand<string>.FromAsyncHandler(MakeShot); this.EditShotCommand = new DelegateCommand<string>(EditShot); this.NewGameCommand = DelegateCommand.FromAsyncHandler(NewGame, CanNewGame); eventAggregator.GetEvent<GameSelected>().Subscribe((payload) => this.CurrentGame = payload); _liveBus = ServiceBusFactory.New(sbc => { sbc.UseMsmq(msmq => { msmq.UseMulticastSubscriptionClient(); msmq.VerifyMsmqConfiguration(); }); sbc.ReceiveFrom("msmq://localhost/ramp-festival_live_sender"); sbc.SetNetwork("WORKGROUP"); }); }
public void SetUp() { this.commandService = Substitute.For<ICommandService>(); this.registrationService = Substitute.For<IRegistrationService>(); SystemTime.Set(TimeStamp); }
public OrderPlacedService(IUserService userService, ILoginService loginService, ISession session, IRegistrationService registrationService) { _userService = userService; _loginService = loginService; _session = session; _registrationService = registrationService; }
public OrganizationController(IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper, IRegistrationService registrationService, IWorkflowInstanceService workflowInstanceService, IWorkflowService workflowService) { this.organizationService = organizationService; this.webSecurityService = securityService; this.emailHelper = emailHelper; this.registrationService = registrationService; this.workflowInstanceService = workflowInstanceService; this.workflowService = workflowService; }
/// <summary> /// The register commands. /// </summary> /// <param name="registrationService"> /// The registration service. /// </param> public override void RegisterCommands(IRegistrationService registrationService) { Command command = new Command(AccessLevel.None, "!ping", string.Empty, string.Empty, this.Handler); command.Handler = this.Handler; command.Trigger = "ping"; command.Description = "Returns a pong from a ping"; registrationService.Register(command); }
public Connection(IRegistrationService registrationService, IRequestFactory requestFactory, IIrcClientFactory ircClientFactory) : this() { Contract.Requires<ArgumentNullException>(registrationService != null, "registrationService"); Contract.Requires<ArgumentNullException>(requestFactory != null, "requestFactory"); Contract.Requires<ArgumentNullException>(ircClientFactory != null, "ircClientFactory"); this.registrationService = registrationService; this.requestFactory = requestFactory; this.ircClientFactory = ircClientFactory; }
public RegistrationModule(IRegistrationService registrationService) { Post["/register"] = x => { var request = this.Bind<RegisterUserRequest>(); registrationService.Register(request); return Negotiate.WithStatusCode(HttpStatusCode.OK); }; }
public RegisterPlayerViewModel(IRegistrationService registrationService) { _registrationService = registrationService; _submitCommand = DelegateCommand.FromAsyncHandler(Submit, CanSubmit); this.CancelCommand = new DelegateCommand(Cancel); _playerName = string.Empty; this.SetInitialValidState(); }
public GiftCardsController(IGiftCardService giftCardService, IGiftCardOrderService giftCardOrderService, IUserService userService, ILogger logger, IRegistrationService registrationService, IUserMailer userMailer, IGiftOrderConfirmationMailer giftorderConfirmationMailer, ISEOToolStaticPageQueryService seoToolStaticPageQueryService) { _giftCardService = giftCardService; _giftCardOrderService = giftCardOrderService; _registrationService = registrationService; _userService = userService; _userMailer = userMailer; _giftorderConfirmationMailer = giftorderConfirmationMailer; _logger = logger; _seoToolStaticPageQueryService = seoToolStaticPageQueryService; }
/// <summary> /// Initializes a new instance of the <see cref="CertificateController"/> class. /// </summary> /// <param name="uc">The uc.</param> /// <param name="dlgService">The dialog service.</param> /// <param name="vm">The vm.</param> public CertificateController(IUnityContainer uc, IDialogService dlgService, CertificateViewModel vm, IRegistrationService eZServ, ICertificateService certService) : base(dlgService) { _uc = uc; _vm = vm; _eZService = eZServ; _certService = certService; }
public AttendeeController(IRepository<Seminar> seminarRespository, IRepositoryWithTypedId<User, Guid> userRepository, IRepository<SeminarPerson> seminarPersonRepository , IRepository<Person> personRepository, IRepository<Firm> firmRepository , IPersonService personService, IRegistrationService registrationService, IFirmService firmService, Agribusiness.Web.Services.INotificationService notificationService) { _seminarRespository = seminarRespository; _userRepository = userRepository; _seminarPersonRepository = seminarPersonRepository; _personRepository = personRepository; _firmRepository = firmRepository; _personService = personService; _registrationService = registrationService; _firmService = firmService; _notificationService = notificationService; }
/// <summary> /// Initializes a new instance of the <see cref="AccountController" /> class. /// </summary> /// <param name="userVerificationService">The user verification service.</param> /// <param name="registrationService">The registration service.</param> /// <param name="profileService">The profile service.</param> /// <param name="roleProvider">The role provider.</param> /// <param name="sessionStateService">The session state service.</param> /// <param name="registerFactory">The register factory.</param> public AccountController(IUserVerificationService userVerificationService, IRegistrationService registrationService, IProfileService profileService, IRoleProvider roleProvider, ISessionStateService sessionStateService, IRegisterFactory registerFactory) { this.userVerificationService = userVerificationService; this.registrationService = registrationService; this.profileService = profileService; this.roleProvider = roleProvider; this.sessionService = sessionStateService; this.registerFactory = registerFactory; }
/// <summary> /// Initializes a new instance of the <see cref="RegistrationController"/> class. /// </summary> public RegistrationController(ICommandService commandService, IRegistrationService registrationService) { if (commandService == null) { throw new ArgumentNullException(nameof(commandService)); } if (registrationService == null) { throw new ArgumentNullException(nameof(registrationService)); } this.commandService = commandService; this.registrationService = registrationService; }
public AdminController(IRepositoryWithTypedId<Student, Guid> studentRepository, IRepositoryWithTypedId<MajorCode, string> majorRepository, IStudentService studentService, IEmailService emailService, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, IRegistrationPopulator registrationPopulator, IRepository<Registration> registrationRepository, IErrorService errorService, IReportService reportService) { if (emailService == null) throw new ArgumentNullException("emailService"); _studentRepository = studentRepository; _majorRepository = majorRepository; _studentService = studentService; _emailService = emailService; _majorService = majorService; _ceremonyService = ceremonyService; _registrationService = registrationService; _registrationPopulator = registrationPopulator; _registrationRepository = registrationRepository; _errorService = errorService; _reportService = reportService; }
public ToursController(ITourService tourService, IExperienceQueryService experienceQueryService, IShoppingCartService shoppingCartService, IOrderService orderService, IRegistrationService registrationService, IUserService userService, ILogger logger, IDiscountCodeValidator discountCodeValidator, IUserMailer userMailer, IOrderConfirmationMailer orderConfirmationMailer, ICategoryService categoryService, IPerspectiveService perspectiveService, ISEOToolStaticPageQueryService seoToolStaticPageQueryService, IStudentInquiryMailer mailer) { _tourService = tourService; _experienceQueryService = experienceQueryService; _shoppingCartService = shoppingCartService; _orderService = orderService; _registrationService = registrationService; _userService = userService; _userMailer = userMailer; _orderConfirmationMailer = orderConfirmationMailer; _logger = logger; _discountCodeValidator = discountCodeValidator; _categoryQueryService = categoryService; _perspectiveService = perspectiveService; _seoToolStaticPageQueryService = seoToolStaticPageQueryService; _mailer = mailer; }
public PersonController(IRepository<Person> personRepository, IRepositoryWithTypedId<User, Guid> userRepository, IRepositoryWithTypedId<SeminarRole, string> seminarRoleRepository , IRepository<SeminarPerson> seminarPersonRepository, IRepository<Seminar> seminarRepository, IRepositoryWithTypedId<Agribusiness.Core.Domain.Membership, Guid> membershipRepository , IPictureService pictureService, IPersonService personService, IFirmService firmService, IRegistrationService registrationService , IvCardService vCardService,IEventService eventService, IRepositoryFactory repositoryFactory) { _personRepository = personRepository; _userRepository = userRepository; _seminarRoleRepository = seminarRoleRepository; _seminarPersonRepository = seminarPersonRepository; _seminarRepository = seminarRepository; _membershipRepository = membershipRepository; _pictureService = pictureService; _personService = personService; _firmService = firmService; _registrationService = registrationService; _vCardService = vCardService; _eventService = eventService; _repositoryFactory = repositoryFactory; _membershipService = new AccountMembershipService(); }
public static AdminMajorsViewModel Create(IRepository repository, ICeremonyService ceremonyService, IRegistrationService registrationService, IPrincipal user) { Check.Require(repository != null, "Repository is required."); Check.Require(ceremonyService != null, "ceremonyService is required."); Check.Require(user != null, "user is required."); // get the current user's ceremonies var ceremonies = ceremonyService.GetCeremonies(user.Identity.Name, TermService.GetCurrent()); var participations = repository.OfType<RegistrationParticipation>().Queryable.Where(a => ceremonies.Contains(a.Ceremony)).ToList(); participations = participations.Where(a => a.IsValidForTickets).ToList(); var viewModel = new AdminMajorsViewModel() {CeremonyCounts = new List<CeremonyCounts>()}; // go through all the ceremonies foreach (var a in ceremonies) { var ceremonyCount = new CeremonyCounts() {Ceremony = a, MajorCounts = new List<MajorCount>()}; // go through each of the majors foreach (var b in a.Majors) { var majorCount = new MajorCount() {Major = b}; majorCount.TotalTickets = participations.Where(c => c.Major == b).Sum(c => c.TotalTickets); majorCount.TotalStreaming = participations.Where(c => c.Major == b).Sum(c => c.TotalStreamingTickets); majorCount.ProjectedTickets = participations.Where(c => c.Major == b).Sum(c => c.ProjectedTickets); majorCount.ProjectedStreamingTickets = participations.Where(c => c.Major == b).Sum(c => c.ProjectedStreamingTickets); if (majorCount.TotalTickets > 0 || majorCount.TotalStreaming > 0 || majorCount.ProjectedTickets > 0 || majorCount.ProjectedStreamingTickets > 0) { ceremonyCount.MajorCounts.Add(majorCount); } } viewModel.CeremonyCounts.Add(ceremonyCount); } return viewModel; }
public RegistrationController(IRegistrationService registrationService, IStringResourceProvider stringResourceProvider) { _registrationService = registrationService; _stringResourceProvider = stringResourceProvider; }
public IRSOrganizationController(IRegistrationService registrationService, IOrganizationService organizationService) { this.registrationService = registrationService; this.organizationService = organizationService; }
public ToursController(ITourService tourService, IExperienceQueryService experienceQueryService, IShoppingCartService shoppingCartService, IOrderService orderService, IRegistrationService registrationService, IUserService userService, ILogger logger, IDiscountCodeValidator discountCodeValidator, IUserMailer userMailer, IOrderConfirmationMailer orderConfirmationMailer, ICategoryService categoryService, IPerspectiveService perspectiveService, ISEOToolStaticPageQueryService seoToolStaticPageQueryService, IStudentInquiryMailer mailer) { _tourService = tourService; _experienceQueryService = experienceQueryService; _shoppingCartService = shoppingCartService; _orderService = orderService; _registrationService = registrationService; _userService = userService; _userMailer = userMailer; _orderConfirmationMailer = orderConfirmationMailer; _logger = logger; _discountCodeValidator = discountCodeValidator; _categoryQueryService = categoryService; _perspectiveService = perspectiveService; _seoToolStaticPageQueryService = seoToolStaticPageQueryService; _mailer = mailer; }
private void Register() { registrationService = RegistrationManager.ProviderRegistrationService; registrationService.Register(); }
public RegistrationsController(IRegistrationService registrationService, IUserMailer userMailer) { _registrationService = registrationService; _userMailer = userMailer; }
public RegistrationController(IRegistrationService iRegistrationService) { _iregistrationService = iRegistrationService; }
public ProfileController(IRegistrationService registrationService, IProfileService userService, UserManager <User> userManager) { _registrationService = registrationService; _userService = userService; _userManager = userManager; }
public RegistrationController(ILogger <RegistrationController> logger, IRegistrationService registrationService) { _logger = logger; _registrationService = registrationService; }
public override void RegisterCommands(IRegistrationService registrationService) { registrationService.Register(new Command(AccessLevel.None, "!weather", "Weather data", "!weather [post code]", this.WeatherRequestAsync)); }
public virtual IHttpActionResult BroadcastEvents(string zoneId = null, string contextId = null) { var eventService = Service as IEventService <TMultiple>; bool eventsSupported = (eventService != null); if (!eventsSupported) { return(BadRequest("Support for SIF Events has not been implemented.")); } IHttpActionResult result; try { IRegistrationService registrationService = RegistrationManager.GetProviderRegistrationService( ProviderSettings, SessionsManager.ProviderSessionService); if (registrationService is NoRegistrationService) { result = BadRequest("SIF Events are only supported in a BROKERED environment."); } else { IEventIterator <TMultiple> eventIterator = eventService.GetEventIterator(zoneId, contextId); if (eventIterator == null) { result = BadRequest("SIF Events implementation is not valid."); } else { Model.Infrastructure.Environment environment = registrationService.Register(); // Retrieve the current Authorisation Token. AuthorisationToken token = registrationService.AuthorisationToken; // Retrieve the EventsConnector endpoint URL. string url = EnvironmentUtils.ParseServiceUrl( environment, ServiceType.UTILITY, InfrastructureServiceNames.eventsConnector); while (eventIterator.HasNext()) { SifEvent <TMultiple> sifEvent = eventIterator.GetNext(); var requestHeaders = new NameValueCollection() { { EventParameterType.eventAction.ToDescription(), sifEvent.EventAction.ToDescription() }, { EventParameterType.messageId.ToDescription(), sifEvent.Id.ToString() }, { EventParameterType.messageType.ToDescription(), "EVENT" }, { EventParameterType.serviceName.ToDescription(), $"{TypeName}s" } }; switch (sifEvent.EventAction) { case EventAction.UPDATE_FULL: requestHeaders.Add(EventParameterType.Replacement.ToDescription(), "FULL"); break; case EventAction.UPDATE_PARTIAL: requestHeaders.Add(EventParameterType.Replacement.ToDescription(), "PARTIAL"); break; } string requestBody = SerialiseEvents(sifEvent.SifObjects); HttpUtils.PostRequest( url, token, requestBody, ProviderSettings.CompressPayload, contentTypeOverride: ContentType.ToDescription(), acceptOverride: Accept.ToDescription(), requestHeaders: requestHeaders); } } result = Ok(); } } catch (Exception e) { result = InternalServerError(e); } return(result); }
public AccountController(IRegistrationService registrationService,IAuthAndPayService authAndPayService) { this.registrationService = registrationService; this.authAndPayService = authAndPayService; }
public OrganizationController(IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper, IRegistrationService registrationService, IWorkflowInstanceService workflowInstanceService, IWorkflowService workflowService) { this.organizationService = organizationService; this.webSecurityService = securityService; this.emailHelper = emailHelper; this.registrationService = registrationService; this.workflowInstanceService = workflowInstanceService; this.workflowService = workflowService; }
/// <summary> /// Register this SIF Provider with the EnvironmentProvider based upon settings defined in the SIF 3.0 /// Framework configuration, e.g. SifFramework.config. /// </summary> private void Register() { registrationService = RegistrationManager.ProviderRegistrationService; registrationService.Register(); }
public RegistrationController(ILogger <RegistrationController> logger, IRegistrationService registrationService) : base(logger) { _registrationService = registrationService; }
public VaccinatieController(IRegistrationService registrationService) { _registrationService = registrationService; }
private void Register() { if (registrationService == null) { log.Info("Getting registration manager..."); registrationService = RegistrationManager.ProviderRegistrationService; } if (!registrationService.Registered) { log.Info("Registering..."); registrationService.Register(); } }
public RegisterationController(IRegistrationService registrationService, ILogger <RegisterationController> logger) { _registrationService = registrationService; _logger = logger; }
public RegistrationController(IRegistrationService service) { _service = service; }
public RegistrationController(IRegistrationService service) { this._service = service; }
public OrgsByCategoryController(IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper, IRegistrationService registrationService) { this.organizationService = organizationService; this.webSecurityService = securityService; this.emailHelper = emailHelper; this.registrationService = registrationService; }
protected override void Launch() { _applicationStateManager = new ApplicationStateManager(Kernel, Args); Core.Utilities.PrepareFirstLaunch(); ILogger logger = Kernel.Get <ILogger>(); if (_applicationStateManager.FocusExistingInstance()) { logger.Information("Shutting down because a different instance is already running."); Application.Current.Shutdown(1); return; } try { DPIAwareness.Initalize(); } catch (Exception ex) { logger.Error($"Failed to set DPI-Awareness: {ex.Message}"); } IViewManager viewManager = Kernel.Get <IViewManager>(); StartupArguments = Args.ToList(); // Create the Artemis core try { _core = Kernel.Get <ICoreService>(); } catch (Exception e) { HandleFatalException(e, logger); throw; } // Ensure WPF uses the right culture in binding converters FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag))); // Create and bind the root view, this is a tray icon so don't show it with the window manager Execute.OnUIThreadSync(() => { UIElement view = viewManager.CreateAndBindViewForModelIfNecessary(RootViewModel); ((TrayViewModel)RootViewModel).SetTaskbarIcon(view); }); // Initialize the core async so the UI can show the progress Task.Run(() => { try { _core.StartupArguments = StartupArguments; _core.IsElevated = _applicationStateManager.IsElevated; _core.Initialize(); } catch (Exception e) { HandleFatalException(e, logger); throw; } }); IRegistrationService registrationService = Kernel.Get <IRegistrationService>(); registrationService.RegisterInputProvider(); registrationService.RegisterControllers(); Execute.OnUIThreadSync(() => { registrationService.ApplyPreferredGraphicsContext(); }); // Initialize background services Kernel.Get <IDeviceLayoutService>(); }
public CustomerRegistrationController(IRegistrationService service) { this.service = service; }
public AnnualRegistrationServiceController(ISession session, IRegistrationService registrationService) { this.session = session; this.registrationService = registrationService; }
public RegistrationController(IRegistrationService registrationService, IUserRepository userRepository) { this.registrationService = registrationService; this.userRepository = userRepository; }
public OrdersModel(IOrderService orders, IEventInfoService eventInfos, IRegistrationService registrations) { _eventInfos = eventInfos; _orders = orders; _registrations = registrations; }
public RegistrationController(IRegistrationService registrationService) { this.registrationService = registrationService; }
public RegistrationsController(IRegistrationService registrationService) { _registrationService = registrationService; }
public RegistrationController(IUnitOfWork unitOfWork, IRegistrationService registrationService) : base(unitOfWork) { _registrationService = registrationService; }
public void Scenario(Registration registration, Registration otherRegistration, Car car, Car otherCar, IRegistrationService registrationService) { "Given a registration service" .f(() => registrationService = new RegistrationService()); "And a registration" .f(() => registration = new Registration("abc", registrationService)); "And a registration with a number that differs by case" .f(() => otherRegistration = new Registration("ABC", registrationService)); "When two cars are instantiated with those registrations" .f(() => { car = new Car(registration); otherCar = new Car(otherRegistration); }); "Then the cars are equal" .f(() => car.Should().NotBe(otherCar)); }
public RegistrationController(IUnitOfWorkVisitRegistration uow, IRegistrationService registrationService) { _uow = uow; _registrationService = registrationService; }
public StudentRegistrationController(ICourseService courseService, IRegistrationService registrationService) { _courseService = courseService; _registrationService = registrationService; }
public virtual IHttpActionResult BroadcastEvents(string zoneId = null, string contextId = null) { IEventService <TMultiple> eventService = service as IEventService <TMultiple>; bool eventsSupported = (eventService != null); if (!eventsSupported) { return(BadRequest("Support for SIF Events has not been implemented.")); } IHttpActionResult result; try { IRegistrationService registrationService = RegistrationManager.ProviderRegistrationService; if (registrationService is NoRegistrationService) { result = BadRequest("SIF Events are only supported in a BROKERED environment."); } else { IEventIterator <TMultiple> eventIterator = eventService.GetEventIterator(zoneId, contextId); if (eventIterator == null) { result = BadRequest("SIF Events implementation is not valid."); } else { // Retrieve the current Authorisation Token. registrationService.Register(); AuthorisationToken token = registrationService.AuthorisationToken; // Retrieve the EventsConnector endpoint URL. Environment environmentTemplate = EnvironmentUtils.LoadFromSettings(SettingsManager.ProviderSettings); string storedSessionToken = SessionsManager.ProviderSessionService.RetrieveSessionToken( environmentTemplate.ApplicationInfo.ApplicationKey, environmentTemplate.SolutionId, environmentTemplate.UserToken, environmentTemplate.InstanceId); Environment environment = authService.GetEnvironmentBySessionToken(storedSessionToken); string url = EnvironmentUtils.ParseServiceUrl(environment, ServiceType.UTILITY, InfrastructureServiceNames.eventsConnector) + "/" + TypeName + "s"; while (eventIterator.HasNext()) { SifEvent <TMultiple> sifEvent = eventIterator.GetNext(); NameValueCollection headerFields = new NameValueCollection() { { HttpUtils.RequestHeader.eventAction.ToDescription(), sifEvent.EventAction.ToDescription() }, { HttpUtils.RequestHeader.messageId.ToDescription(), sifEvent.Id.ToString() }, { HttpUtils.RequestHeader.messageType.ToDescription(), "EVENT" }, { HttpUtils.RequestHeader.serviceName.ToDescription(), $"{TypeName}s" } }; switch (sifEvent.EventAction) { case EventAction.UPDATE_FULL: headerFields.Add(HttpUtils.RequestHeader.Replacement.ToDescription(), "FULL"); break; case EventAction.UPDATE_PARTIAL: headerFields.Add(HttpUtils.RequestHeader.Replacement.ToDescription(), "PARTIAL"); break; } string body = SerialiseEvents(sifEvent.SifObjects); string xml = HttpUtils.PostRequest(url, token, body, headerFields: headerFields); } } result = Ok(); } } catch (Exception e) { result = InternalServerError(e); } return(result); }
public AuthController(IAuthService authService, IRegistrationService registrationService) { this.authService = authService; this.registrationService = registrationService; }
public GuestRequired(IRegistrationService registrationService) { _registrationService = registrationService; }
public TFSSourceControlService(IRegistrationService registrationService, IRepositoryWebSvcFactory webSvcFactory, IWebTransferService webTransferService, IFileSystem fileSystem, DefaultLogger logger) : base(registrationService, webSvcFactory, webTransferService, fileSystem) { this.webSvcFactory = webSvcFactory; this.logger = logger; }
public RegistrationsController(IRegistrationService registrationService) => this.registrationService = registrationService;
public RegistrationDataProvider(IRegistrationService registrationService) { _registrationService = registrationService; }
public DetailsModel(UserManager <ApplicationUser> userManager, IRegistrationService registrationService) { _userManager = userManager; _registrationService = registrationService; }
public RegistrationController(IRegistrationService registrationService, ILoggerManager logger) { _registrationService = registrationService; _logger = logger; }
public abstract void RegisterCommands(IRegistrationService registrationService);
public ApartmentsController(IRegistrationService registrationService) { _registrationService = registrationService; }