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;
}
