예제 #1
0
 private void Register()
 {
     registrationService = RegistrationManager.GetProviderRegistrationService(
         SettingsManager.ProviderSettings,
         SessionsManager.ProviderSessionService);
     registrationService.Register();
 }
예제 #2
0
 /// <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(IFrameworkSettings settings)
 {
     registrationService = RegistrationManager.GetProviderRegistrationService(
         settings,
         SessionsManager.ProviderSessionService);
     registrationService.Register();
 }
예제 #3
0
        private void Register()
        {
            if (registrationService == null)
            {
                log.Info("Getting registration manager...");
                registrationService = RegistrationManager.GetProviderRegistrationService(
                    SettingsManager.ProviderSettings,
                    SessionsManager.ProviderSessionService);
            }

            if (!registrationService.Registered)
            {
                log.Info("Registering...");
                registrationService.Register();
            }
        }
예제 #4
0
        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,
                    sessionService);

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