/// <summary>
/// Create a Consumer instance identified by the parameters passed.
/// </summary>
/// <param name="applicationKey">Application key.</param>
/// <param name="instanceId">Instance ID.</param>
/// <param name="userToken">User token.</param>
/// <param name="solutionId">Solution ID.</param>
public Consumer(string applicationKey, string instanceId = null, string userToken = null, string solutionId = null)
{
Environment environment = new Environment(applicationKey, instanceId, userToken, solutionId);
environmentTemplate = EnvironmentUtils.MergeWithSettings(environment, SettingsManager.ConsumerSettings);
registrationService = new RegistrationService(SettingsManager.ConsumerSettings, SessionsManager.ConsumerSessionService);
}
public void SaveAndRetrieveByExample()
{
// Save a new Environment.
Environment saved = DataFactory.CreateEnvironmentRequest();
environmentRepository.Save(saved);
// Create an example Environment instance for use in the retrieve call.
ApplicationInfo applicationInfo = new ApplicationInfo {
ApplicationKey = "UnitTesting"
};
Environment example = new Environment
{
ApplicationInfo = applicationInfo,
InstanceId = saved.InstanceId,
SessionToken = saved.SessionToken,
SolutionId = saved.SolutionId,
UserToken = saved.UserToken
};
// Retrieve Environments based on the example Environment instance.
IEnumerable <Environment> environments = environmentRepository.Retrieve(example);
// Assert that the retrieved Environments match properties of the example Environment instance.
foreach (Environment retrieved in environments)
{
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.InstanceId, retrieved.InstanceId);
Assert.AreEqual(saved.SessionToken, retrieved.SessionToken);
Assert.AreEqual(saved.Id, retrieved.Id);
Assert.AreEqual(saved.SolutionId, retrieved.SolutionId);
Assert.AreEqual(saved.UserToken, retrieved.UserToken);
}
}
public void SaveAndRetrieveBySessionToken()
{
Environment saved = DataFactory.CreateEnvironmentRequest();
Guid environmentId = (new EnvironmentRepository()).Save(saved);
ApplicationInfo applicationInfo = new ApplicationInfo
{
ApplicationKey = "UnitTesting",
};
Environment example = new Environment
{
ApplicationInfo = applicationInfo,
InstanceId = "ThisInstance01",
SessionToken = "2e5dd3ca282fc8ddb3d08dcacc407e8a",
SolutionId = "auTestSolution",
UserToken = "UserToken01"
};
Environment retrieved = (new EnvironmentRepository()).RetrieveBySessionToken("2e5dd3ca282fc8ddb3d08dcacc407e8a");
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.InstanceId, retrieved.InstanceId);
Assert.AreEqual(saved.SessionToken, retrieved.SessionToken);
Assert.AreEqual(saved.Id, retrieved.Id);
Assert.AreEqual(saved.SolutionId, retrieved.SolutionId);
Assert.AreEqual(saved.UserToken, retrieved.UserToken);
}
/// <summary>
/// Create a Consumer instance based upon the Environment passed.
/// </summary>
/// <param name="environment">Environment object.</param>
/// <param name="settings">Consumer settings. If null, Consumer settings will be read from the SifFramework.config file.</param>
public FunctionalServiceConsumer(Environment environment, IFrameworkSettings settings = null)
{
ConsumerSettings = settings ?? SettingsManager.ConsumerSettings;
environmentTemplate = EnvironmentUtils.MergeWithSettings(environment, ConsumerSettings);
registrationService = new RegistrationService(ConsumerSettings, SessionsManager.ConsumerSessionService);
}
/// <summary>
/// Create a Consumer instance based upon the Environment passed.
/// </summary>
/// <param name="environment">Environment object.</param>
/// <param name="settings">Consumer settings. If null, Consumer settings will be read from the SifFramework.config file.</param>
/// <param name="sessionService">Consumer session service. If null, the Consumer session will be stored in the SifFramework.config file.</param>
protected Consumer(
Environment environment,
IFrameworkSettings settings = null,
ISessionService sessionService = null)
{
ConsumerSettings = settings ?? SettingsManager.ConsumerSettings;
environmentTemplate = EnvironmentUtils.MergeWithSettings(environment, ConsumerSettings);
RegistrationService =
new RegistrationService(ConsumerSettings, sessionService ?? SessionsManager.ConsumerSessionService);
}
/// <summary>
/// Create an Environment instance from properties defined in the framework settings.
/// </summary>
/// <param name="settings">Framework settings.</param>
/// <returns>Environment instance.</returns>
internal static Environment LoadFromSettings(IFrameworkSettings settings)
{
Environment merged = new Environment();
if (merged.ApplicationInfo == null)
{
merged.ApplicationInfo = new ApplicationInfo();
}
if (string.IsNullOrWhiteSpace(settings.ApplicationKey))
{
throw new ConfigurationErrorsException("An applicationKey must be defined in the Provider Environment template.");
}
else
{
merged.ApplicationInfo.ApplicationKey = settings.ApplicationKey;
}
if (!string.IsNullOrWhiteSpace(settings.SolutionId))
{
merged.SolutionId = settings.SolutionId;
}
if (!string.IsNullOrWhiteSpace(settings.UserToken))
{
merged.UserToken = settings.UserToken;
}
if (!string.IsNullOrWhiteSpace(settings.InstanceId))
{
merged.InstanceId = settings.InstanceId;
}
if (!string.IsNullOrWhiteSpace(settings.AuthenticationMethod))
{
merged.AuthenticationMethod = settings.AuthenticationMethod;
}
if (!string.IsNullOrWhiteSpace(settings.ConsumerName))
{
merged.ConsumerName = settings.ConsumerName;
}
if (!string.IsNullOrWhiteSpace(settings.DataModelNamespace))
{
merged.ApplicationInfo.DataModelNamespace = settings.DataModelNamespace;
}
if (!string.IsNullOrWhiteSpace(settings.SupportedInfrastructureVersion))
{
merged.ApplicationInfo.SupportedInfrastructureVersion = settings.SupportedInfrastructureVersion;
}
return(merged);
}
public void SaveAndRetrieve()
{
Environment saved = DataFactory.CreateEnvironmentRequest();
Guid environmentId = (new EnvironmentRepository()).Save(saved);
Environment retrieved = (new EnvironmentRepository()).Retrieve(environmentId);
Assert.AreEqual(saved.Type, retrieved.Type);
Assert.AreEqual(saved.AuthenticationMethod, retrieved.AuthenticationMethod);
Assert.AreEqual(saved.ConsumerName, retrieved.ConsumerName);
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.ApplicationInfo.SupportedInfrastructureVersion, retrieved.ApplicationInfo.SupportedInfrastructureVersion);
Assert.AreEqual(saved.ApplicationInfo.DataModelNamespace, retrieved.ApplicationInfo.DataModelNamespace);
}
/// <summary>
/// Parse the Environment object for the service URL.
/// </summary>
/// <param name="environment">Environment object to parse.</param>
/// <returns>Service URL.</returns>
internal static string ParseServiceUrl(Environment environment)
{
string serviceUrl = null;
if (environment != null &&
environment.InfrastructureServices != null &&
environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector] != null &&
environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector].Value != null)
{
serviceUrl = environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector].Value;
}
return(serviceUrl);
}
/// <summary>
/// Combine the passed in environment object with the equivalent properties defined in the framework settings
/// (if present). Properties that already exist in the passed in the environment take precedence over the
/// properties defined in the framework settings.
/// </summary>
/// <param name="environment">Environment object to check.</param>
/// <param name="settings">Framework settings.</param>
/// <returns>Environment object with merged properties.</returns>
internal static Environment MergeWithSettings(Environment environment, IFrameworkSettings settings)
{
Environment merged;
if (environment == null)
{
merged = new Environment();
}
else
{
merged = environment;
}
if (merged.ApplicationInfo == null)
{
merged.ApplicationInfo = new ApplicationInfo();
}
if (string.IsNullOrWhiteSpace(merged.ApplicationInfo.ApplicationKey) && settings.ApplicationKey != null)
{
merged.ApplicationInfo.ApplicationKey = settings.ApplicationKey;
}
if (string.IsNullOrWhiteSpace(merged.ApplicationInfo.ApplicationKey))
{
throw new ArgumentException("An applicationKey must either be provided or defined in the Consumer Environment template.", "applicationKey");
}
if (string.IsNullOrWhiteSpace(merged.AuthenticationMethod) && settings.AuthenticationMethod != null)
{
merged.AuthenticationMethod = settings.AuthenticationMethod;
}
if (string.IsNullOrWhiteSpace(merged.ConsumerName) && settings.ConsumerName != null)
{
merged.ConsumerName = settings.ConsumerName;
}
if (string.IsNullOrWhiteSpace(merged.ApplicationInfo.DataModelNamespace) && settings.DataModelNamespace != null)
{
merged.ApplicationInfo.DataModelNamespace = settings.DataModelNamespace;
}
if (string.IsNullOrWhiteSpace(merged.ApplicationInfo.SupportedInfrastructureVersion) && settings.SupportedInfrastructureVersion != null)
{
merged.ApplicationInfo.SupportedInfrastructureVersion = settings.SupportedInfrastructureVersion;
}
return(merged);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private static EnvironmentRegister CreateEnvironmentRegister(Environment environmentRequest, Environment environmentResponse)
{
EnvironmentRegister environmentRegister = new EnvironmentRegister
{
ApplicationKey = environmentRequest.ApplicationInfo.ApplicationKey,
DefaultZone = environmentResponse.DefaultZone,
InfrastructureServices = environmentResponse.InfrastructureServices,
InstanceId = environmentRequest.InstanceId,
ProvisionedZones = environmentResponse.ProvisionedZones,
SolutionId = environmentRequest.SolutionId,
UserToken = environmentRequest.UserToken
};
return(environmentRegister);
}
public void SaveAndRetrieve()
{
// Save a new Environment and then retrieve it using it's identifier.
Environment saved = DataFactory.CreateEnvironmentRequest();
Guid environmentId = environmentRepository.Save(saved);
Environment retrieved = environmentRepository.Retrieve(environmentId);
// Assert that the retrieved Environment matches the saved Environment.
Assert.AreEqual(saved.Type, retrieved.Type);
Assert.AreEqual(saved.AuthenticationMethod, retrieved.AuthenticationMethod);
Assert.AreEqual(saved.ConsumerName, retrieved.ConsumerName);
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.ApplicationInfo.SupportedInfrastructureVersion, retrieved.ApplicationInfo.SupportedInfrastructureVersion);
Assert.AreEqual(saved.ApplicationInfo.DataModelNamespace, retrieved.ApplicationInfo.DataModelNamespace);
}
public void SaveAndRetrieveBySessionToken()
{
// Save a new Environment and then retrieve it based on it's session token.
Environment saved = DataFactory.CreateEnvironmentRequest();
environmentRepository.Save(saved);
Environment retrieved = environmentRepository.RetrieveBySessionToken(saved.SessionToken);
// Assert that the retrieved Environment matches the saved Environment.
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.InstanceId, retrieved.InstanceId);
Assert.AreEqual(saved.SessionToken, retrieved.SessionToken);
Assert.AreEqual(saved.Id, retrieved.Id);
Assert.AreEqual(saved.SolutionId, retrieved.SolutionId);
Assert.AreEqual(saved.UserToken, retrieved.UserToken);
}
private static ApplicationRegister CreateApplicationRegister(string path)
{
environmentType environmentTypeRequest;
environmentType environmentTypeResponse;
string request = @path + "\\EnvironmentRequest.xml";
string response = @path + "\\EnvironmentResponse.xml";
if (!File.Exists(request) || !File.Exists(response))
{
return(null);
}
Console.WriteLine("");
Console.WriteLine("Processsing input from: " + path);
Console.WriteLine("Request: " + request);
Console.WriteLine("Response: " + response);
Console.WriteLine("");
using (FileStream xmlStream = File.OpenRead(request))
{
environmentTypeRequest = SerialiserFactory.GetXmlSerialiser <environmentType>().Deserialise(xmlStream);
}
using (FileStream xmlStream = File.OpenRead(response))
{
environmentTypeResponse = SerialiserFactory.GetXmlSerialiser <environmentType>().Deserialise(xmlStream);
}
Environment environmentRequest = MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeRequest);
Environment environmentResponse = MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeResponse);
EnvironmentRegister environmentRegister = CreateEnvironmentRegister(environmentRequest, environmentResponse);
ApplicationRegister applicationRegister = new ApplicationRegister
{
ApplicationKey = environmentRequest.ApplicationInfo.ApplicationKey,
SharedSecret = "SecretDem0",
EnvironmentRegisters = new Collection <EnvironmentRegister> {
{ environmentRegister }
}
};
return(applicationRegister);
}
/// <summary>
/// Create an Environment instance from properties defined in the framework settings.
/// </summary>
/// <param name="settings">Framework settings.</param>
/// <returns>Environment instance.</returns>
internal static Environment LoadFromSettings(IFrameworkSettings settings)
{
Environment merged = new Environment();
if (merged.ApplicationInfo == null)
{
merged.ApplicationInfo = new ApplicationInfo();
}
if (String.IsNullOrWhiteSpace(settings.ApplicationKey))
{
throw new ConfigurationErrorsException("An applicationKey must be defined in the Provider Environment template.");
}
else
{
merged.ApplicationInfo.ApplicationKey = settings.ApplicationKey;
}
if (!String.IsNullOrWhiteSpace(settings.AuthenticationMethod))
{
merged.AuthenticationMethod = settings.AuthenticationMethod;
}
if (!String.IsNullOrWhiteSpace(settings.ConsumerName))
{
merged.ConsumerName = settings.ConsumerName;
}
if (!String.IsNullOrWhiteSpace(settings.DataModelNamespace))
{
merged.ApplicationInfo.DataModelNamespace = settings.DataModelNamespace;
}
if (!String.IsNullOrWhiteSpace(settings.SupportedInfrastructureVersion))
{
merged.ApplicationInfo.SupportedInfrastructureVersion = settings.SupportedInfrastructureVersion;
}
return merged;
}
/// <summary>
/// Internal method to check if a given right is supported by the ACL.
/// </summary>
/// <param name="serviceName">The name of the service to check</param>
/// <param name="zone">The zone to check authorization in</param>
/// <param name="context">The context to check authorization in</param>
/// <param name="right">The right to check</param>
/// <returns>The session token if authorized, otherwise a HttpResponseException is thrown</returns>
protected virtual string CheckAuthorisation(string serviceName, string[] zone, string[] context, Right right)
{
string sessionToken = CheckAuthorisation(zone, context);
Environment environment = authService.GetEnvironmentBySessionToken(sessionToken);
if (environment == null)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request failed as could not retrieve environment XML."));
}
try
{
RightsUtils.CheckRight(getRights(serviceName, EnvironmentUtils.GetTargetZone(environment, zone == null ? null : zone[0])), right);
log.Debug("Functional Service " + serviceName + " has expected ACL (" + right.Type + ":" + right.Value + ")");
return(sessionToken);
}
catch (RejectedException e)
{
string msg = "Functional Service " + serviceName + " does not have sufficient access rights to perform an " + right.Type + " operation: " + e.Message;
log.Debug(msg);
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Forbidden, msg, e));
}
}
public static ProvisionedZone GetTargetZone(Environment environment, string zoneId = null)
{
// Return the requested zone
if (StringUtils.NotEmpty(zoneId))
{
return(environment.ProvisionedZones[zoneId]);
}
// No zone, so try getting the default zone
if (StringUtils.NotEmpty(environment.DefaultZone.SifId))
{
return(environment.ProvisionedZones[environment.DefaultZone.SifId]);
}
// No default zone defined
// Fallback: If there is exactly one zone defined then return that
if (environment.ProvisionedZones != null && environment.ProvisionedZones.Count == 1)
{
return(environment.ProvisionedZones.Values.FirstOrDefault());
}
return(null);
}
public void Retrieve()
{
// Save a new Environment and then retrieve it using it's identifier.
Environment saved = DataFactory.CreateEnvironmentRequest();
Guid environmentId = environmentRepository.Save(saved);
environmentType retrieved = environmentService.Retrieve(environmentId);
// Assert that the retrieved Environment matches the saved Environment.
Assert.AreEqual(saved.ApplicationInfo.AdapterProduct.IconURI, retrieved.applicationInfo.adapterProduct.iconURI);
Assert.AreEqual(saved.ApplicationInfo.AdapterProduct.ProductName, retrieved.applicationInfo.adapterProduct.productName);
Assert.AreEqual(saved.ApplicationInfo.AdapterProduct.ProductVersion, retrieved.applicationInfo.adapterProduct.productVersion);
Assert.AreEqual(saved.ApplicationInfo.AdapterProduct.VendorName, retrieved.applicationInfo.adapterProduct.vendorName);
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.applicationInfo.applicationKey);
Assert.AreEqual(saved.ApplicationInfo.ApplicationProduct.IconURI, retrieved.applicationInfo.applicationProduct.iconURI);
Assert.AreEqual(saved.ApplicationInfo.ApplicationProduct.ProductName, retrieved.applicationInfo.applicationProduct.productName);
Assert.AreEqual(saved.ApplicationInfo.ApplicationProduct.ProductVersion, retrieved.applicationInfo.applicationProduct.productVersion);
Assert.AreEqual(saved.ApplicationInfo.ApplicationProduct.VendorName, retrieved.applicationInfo.applicationProduct.vendorName);
Assert.AreEqual(saved.ApplicationInfo.DataModelNamespace, retrieved.applicationInfo.dataModelNamespace);
Assert.AreEqual(saved.ApplicationInfo.SupportedInfrastructureVersion, retrieved.applicationInfo.supportedInfrastructureVersion);
Assert.AreEqual(saved.ApplicationInfo.Transport, retrieved.applicationInfo.transport);
Assert.AreEqual(saved.AuthenticationMethod, retrieved.authenticationMethod);
Assert.AreEqual(saved.ConsumerName, retrieved.consumerName);
Assert.AreEqual(saved.DefaultZone.Description, retrieved.defaultZone.description);
}
/// <summary>
/// Parse the Environment object for the service URL.
/// </summary>
/// <param name="environment">Environment object to parse.</param>
/// <param name="serviceType">The type of service to get a connector for.</param>
/// <param name="connector">The type of connector to get, only has an effect when the service type is UTILITY.</param>
/// <returns>Service URL.</returns>
internal static string ParseServiceUrl(Environment environment, ServiceType serviceType = ServiceType.OBJECT, InfrastructureServiceNames connector = InfrastructureServiceNames.requestsConnector)
{
if (environment == null || environment.InfrastructureServices == null)
{
return(null);
}
InfrastructureServiceNames name;
switch (serviceType)
{
case ServiceType.UTILITY:
name = connector;
break;
case ServiceType.FUNCTIONAL:
name = InfrastructureServiceNames.servicesConnector;
break;
case ServiceType.OBJECT:
name = InfrastructureServiceNames.requestsConnector;
break;
default:
name = InfrastructureServiceNames.requestsConnector;
break;
}
if (environment.InfrastructureServices[name] == null ||
environment.InfrastructureServices[name].Value == null)
{
return(null);
}
return(environment.InfrastructureServices[name].Value);
}
/// <summary>
/// Create a Consumer instance based upon the Environment passed.
/// </summary>
/// <param name="environment">Environment object.</param>
public FunctionalServiceConsumer(Environment environment)
{
environmentTemplate = EnvironmentUtils.MergeWithSettings(environment, SettingsManager.ConsumerSettings);
registrationService = new RegistrationService(SettingsManager.ConsumerSettings, SessionsManager.ConsumerSessionService);
}
/// <summary>
/// <see cref="IRegistrationService.Register()">Register</see>
/// </summary>
public Environment Register()
{
Environment environment = EnvironmentUtils.LoadFromSettings(settings);
return(Register(ref environment));
}
/// <summary>
/// <see cref="IRegistrationService.Register(ref Environment)">Register</see>
/// </summary>
public Environment Register(ref Environment environment)
{
if (Registered)
{
return(CurrentEnvironment);
}
if (sessionService.HasSession(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId))
{
if (log.IsDebugEnabled)
{
log.Debug("Session token already exists for this object service (Consumer/Provider).");
}
string storedSessionToken = sessionService.RetrieveSessionToken(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId);
AuthorisationToken = authorisationTokenService.Generate(storedSessionToken, settings.SharedSecret);
string storedEnvironmentUrl = sessionService.RetrieveEnvironmentUrl(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId);
string environmentXml = HttpUtils.GetRequest(storedEnvironmentUrl, AuthorisationToken);
if (log.IsDebugEnabled)
{
log.Debug("Environment XML from GET request ...");
}
if (log.IsDebugEnabled)
{
log.Debug(environmentXml);
}
environmentType environmentTypeToDeserialise = SerialiserFactory.GetXmlSerialiser <environmentType>().Deserialise(environmentXml);
Environment environmentResponse = MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl = environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled)
{
log.Debug("Environment URL is " + environmentUrl + ".");
}
if (!storedSessionToken.Equals(sessionToken) || !storedEnvironmentUrl.Equals(environmentUrl))
{
AuthorisationToken = authorisationTokenService.Generate(sessionToken, settings.SharedSecret);
sessionService.RemoveSession(storedSessionToken);
sessionService.StoreSession(environmentResponse.ApplicationInfo.ApplicationKey, sessionToken, environmentUrl, environmentResponse.SolutionId, environmentResponse.UserToken, environmentResponse.InstanceId);
}
environment = environmentResponse;
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("Session token does not exist for this object service (Consumer/Provider).");
}
AuthorisationToken initialToken = authorisationTokenService.Generate(environment.ApplicationInfo.ApplicationKey, settings.SharedSecret);
environmentType environmentTypeToSerialise = MapperFactory.CreateInstance <Environment, environmentType>(environment);
string body = SerialiserFactory.GetXmlSerialiser <environmentType>().Serialise(environmentTypeToSerialise);
string environmentXml = HttpUtils.PostRequest(settings.EnvironmentUrl, initialToken, body);
if (log.IsDebugEnabled)
{
log.Debug("Environment XML from POST request ...");
}
if (log.IsDebugEnabled)
{
log.Debug(environmentXml);
}
try
{
environmentType environmentTypeToDeserialise = SerialiserFactory.GetXmlSerialiser <environmentType>().Deserialise(environmentXml);
Environment environmentResponse = MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl = environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled)
{
log.Debug("Environment URL is " + environmentUrl + ".");
}
AuthorisationToken = authorisationTokenService.Generate(sessionToken, settings.SharedSecret);
sessionService.StoreSession(environment.ApplicationInfo.ApplicationKey, sessionToken, environmentUrl, environmentResponse.SolutionId, environmentResponse.UserToken, environmentResponse.InstanceId);
environment = environmentResponse;
}
catch (Exception)
{
if (environmentUrl != null)
{
HttpUtils.DeleteRequest(environmentUrl, AuthorisationToken);
}
else if (!string.IsNullOrWhiteSpace(TryParseEnvironmentUrl(environmentXml)))
{
HttpUtils.DeleteRequest(TryParseEnvironmentUrl(environmentXml), AuthorisationToken);
}
throw;
}
}
CurrentEnvironment = environment;
Registered = true;
return(CurrentEnvironment);
}
public void SaveAndRetrieveByExample()
{
Environment saved = DataFactory.CreateEnvironmentRequest();
Guid environmentId = (new EnvironmentRepository()).Save(saved);
ApplicationInfo applicationInfo = new ApplicationInfo
{
ApplicationKey = "UnitTesting", };
Environment example = new Environment
{
ApplicationInfo = applicationInfo,
InstanceId = "ThisInstance01",
SessionToken = "2e5dd3ca282fc8ddb3d08dcacc407e8a",
SolutionId = "auTestSolution",
UserToken = "UserToken01"
};
IEnumerable<Environment> environments = (new EnvironmentRepository()).Retrieve(example);
foreach (Environment retrieved in environments)
{
Assert.AreEqual(saved.ApplicationInfo.ApplicationKey, retrieved.ApplicationInfo.ApplicationKey);
Assert.AreEqual(saved.InstanceId, retrieved.InstanceId);
Assert.AreEqual(saved.SessionToken, retrieved.SessionToken);
Assert.AreEqual(saved.Id, retrieved.Id);
Assert.AreEqual(saved.SolutionId, retrieved.SolutionId);
Assert.AreEqual(saved.UserToken, retrieved.UserToken);
}
}
/// <summary>
/// <see cref="IRegistrationService.Register()">Register</see>
/// </summary>
public Environment Register()
{
Environment environment = EnvironmentUtils.LoadFromSettings(SettingsManager.ProviderSettings);
return(Register(ref environment));
}
/// <summary>
/// <see cref="Sif.Framework.Service.Registration.IRegistrationService.Register()">Register</see>
/// </summary>
public void Register()
{
Environment environment = EnvironmentUtils.LoadFromSettings(SettingsManager.ProviderSettings);
Register(ref environment);
}
/// <summary>
/// Parse the Environment object for the service URL.
/// </summary>
/// <param name="environment">Environment object to parse.</param>
/// <returns>Service URL.</returns>
internal static string ParseServiceUrl(Environment environment)
{
string serviceUrl = null;
if (environment != null &&
environment.InfrastructureServices != null &&
environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector] != null &&
environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector].Value != null)
{
serviceUrl = environment.InfrastructureServices[InfrastructureServiceNames.requestsConnector].Value;
}
return serviceUrl;
}
/// <summary>
/// <see cref="Sif.Framework.Service.Registration.IRegistrationService.Register(Sif.Framework.Model.Infrastructure.Environment)">Register</see>
/// </summary>
public Environment Register(ref Environment environment)
{
if (Registered)
{
return CurrentEnvironment;
}
if (sessionService.HasSession(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId))
{
if (log.IsDebugEnabled) log.Debug("Session token already exists for this object service (Consumer/Provider).");
string storedSessionToken = sessionService.RetrieveSessionToken(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId);
AuthorisationToken = AuthenticationUtils.GenerateBasicAuthorisationToken(storedSessionToken, settings.SharedSecret);
string storedEnvironmentUrl = sessionService.RetrieveEnvironmentUrl(environment.ApplicationInfo.ApplicationKey, environment.SolutionId, environment.UserToken, environment.InstanceId);
string environmentXml = HttpUtils.GetRequest(storedEnvironmentUrl, AuthorisationToken);
if (log.IsDebugEnabled) log.Debug("Environment XML from GET request ...");
if (log.IsDebugEnabled) log.Debug(environmentXml);
environmentType environmentTypeToDeserialise = SerialiserFactory.GetXmlSerialiser<environmentType>().Deserialise(environmentXml);
Environment environmentResponse = MapperFactory.CreateInstance<environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl = environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled) log.Debug("Environment URL is " + environmentUrl + ".");
if (!storedSessionToken.Equals(sessionToken) || !storedEnvironmentUrl.Equals(environmentUrl))
{
AuthorisationToken = AuthenticationUtils.GenerateBasicAuthorisationToken(sessionToken, settings.SharedSecret);
sessionService.RemoveSession(storedSessionToken);
sessionService.StoreSession(environmentResponse.ApplicationInfo.ApplicationKey, sessionToken, environmentUrl, environmentResponse.SolutionId, environmentResponse.UserToken, environmentResponse.InstanceId);
}
environment = environmentResponse;
}
else
{
if (log.IsDebugEnabled) log.Debug("Session token does not exist for this object service (Consumer/Provider).");
string initialToken = AuthenticationUtils.GenerateBasicAuthorisationToken(environment.ApplicationInfo.ApplicationKey, settings.SharedSecret);
environmentType environmentTypeToSerialise = MapperFactory.CreateInstance<Environment, environmentType>(environment);
string body = SerialiserFactory.GetXmlSerialiser<environmentType>().Serialise(environmentTypeToSerialise);
string environmentXml = HttpUtils.PostRequest(settings.EnvironmentUrl, initialToken, body);
if (log.IsDebugEnabled) log.Debug("Environment XML from POST request ...");
if (log.IsDebugEnabled) log.Debug(environmentXml);
try
{
environmentType environmentTypeToDeserialise = SerialiserFactory.GetXmlSerialiser<environmentType>().Deserialise(environmentXml);
Environment environmentResponse = MapperFactory.CreateInstance<environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl = environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled) log.Debug("Environment URL is " + environmentUrl + ".");
AuthorisationToken = AuthenticationUtils.GenerateBasicAuthorisationToken(sessionToken, settings.SharedSecret);
sessionService.StoreSession(environment.ApplicationInfo.ApplicationKey, sessionToken, environmentUrl, environmentResponse.SolutionId, environmentResponse.UserToken, environmentResponse.InstanceId);
environment = environmentResponse;
}
catch (Exception)
{
if (environmentUrl != null)
{
HttpUtils.DeleteRequest(environmentUrl, AuthorisationToken);
}
else if (!String.IsNullOrWhiteSpace(TryParseEnvironmentUrl(environmentXml)))
{
HttpUtils.DeleteRequest(TryParseEnvironmentUrl(environmentXml), AuthorisationToken);
}
throw;
}
}
CurrentEnvironment = environment;
Registered = true;
return CurrentEnvironment;
}
/// <summary>
/// <see cref="IRegistrationService.Register(ref Environment)">Register</see>
/// </summary>
public Environment Register(ref Environment environment)
{
if (Registered)
{
return(CurrentEnvironment);
}
if (sessionService.HasSession(
environment.ApplicationInfo.ApplicationKey,
environment.SolutionId,
environment.UserToken,
environment.InstanceId))
{
if (log.IsDebugEnabled)
{
log.Debug("Session token already exists for this object service (Consumer/Provider).");
}
string storedSessionToken = sessionService.RetrieveSessionToken(
environment.ApplicationInfo.ApplicationKey,
environment.SolutionId,
environment.UserToken,
environment.InstanceId);
authorisationToken = authorisationTokenService.Generate(storedSessionToken, settings.SharedSecret);
string storedEnvironmentUrl = sessionService.RetrieveEnvironmentUrl(
environment.ApplicationInfo.ApplicationKey,
environment.SolutionId,
environment.UserToken,
environment.InstanceId);
string environmentBody = HttpUtils.GetRequest(
storedEnvironmentUrl,
authorisationToken,
settings.CompressPayload,
contentTypeOverride: settings.ContentType.ToDescription(),
acceptOverride: settings.Accept.ToDescription());
if (log.IsDebugEnabled)
{
log.Debug($"Environment response from GET request ...\n{environmentBody}");
}
environmentType environmentTypeToDeserialise =
SerialiserFactory.GetSerialiser <environmentType>(settings.Accept).Deserialise(environmentBody);
Environment environmentResponse =
MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl =
environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled)
{
log.Debug($"Environment URL is {environmentUrl}.");
}
if (!storedSessionToken.Equals(sessionToken) || !storedEnvironmentUrl.Equals(environmentUrl))
{
authorisationToken = authorisationTokenService.Generate(sessionToken, settings.SharedSecret);
sessionService.RemoveSession(storedSessionToken);
sessionService.StoreSession(
environmentResponse.ApplicationInfo.ApplicationKey,
sessionToken,
environmentUrl,
environmentResponse.SolutionId,
environmentResponse.UserToken,
environmentResponse.InstanceId);
}
environment = environmentResponse;
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("Session token does not exist for this object service (Consumer/Provider).");
}
string environmentBody = null;
try
{
AuthorisationToken initialToken = authorisationTokenService.Generate(
environment.ApplicationInfo.ApplicationKey,
settings.SharedSecret);
environmentType environmentTypeToSerialise =
MapperFactory.CreateInstance <Environment, environmentType>(environment);
string body = SerialiserFactory.GetSerialiser <environmentType>(settings.ContentType)
.Serialise(environmentTypeToSerialise);
environmentBody = HttpUtils.PostRequest(
settings.EnvironmentUrl,
initialToken,
body,
settings.CompressPayload,
contentTypeOverride: settings.ContentType.ToDescription(),
acceptOverride: settings.Accept.ToDescription());
if (log.IsDebugEnabled)
{
log.Debug($"Environment response from POST request ...\n{environmentBody}");
}
environmentType environmentTypeToDeserialise =
SerialiserFactory.GetSerialiser <environmentType>(settings.Accept).Deserialise(environmentBody);
Environment environmentResponse =
MapperFactory.CreateInstance <environmentType, Environment>(environmentTypeToDeserialise);
sessionToken = environmentResponse.SessionToken;
environmentUrl =
environmentResponse.InfrastructureServices[InfrastructureServiceNames.environment].Value;
if (log.IsDebugEnabled)
{
log.Debug($"Environment URL is {environmentUrl}.");
}
authorisationToken = authorisationTokenService.Generate(sessionToken, settings.SharedSecret);
sessionService.StoreSession(
environment.ApplicationInfo.ApplicationKey,
sessionToken,
environmentUrl,
environmentResponse.SolutionId,
environmentResponse.UserToken,
environmentResponse.InstanceId);
environment = environmentResponse;
}
catch (Exception e)
{
if (environmentUrl != null)
{
HttpUtils.DeleteRequest(environmentUrl, authorisationToken, settings.CompressPayload);
}
else if (!string.IsNullOrWhiteSpace(TryParseEnvironmentUrl(environmentBody)))
{
HttpUtils.DeleteRequest(
TryParseEnvironmentUrl(environmentBody),
authorisationToken,
settings.CompressPayload);
}
throw new RegistrationException("Registration failed.", e);
}
}
CurrentEnvironment = environment;
Registered = true;
return(CurrentEnvironment);
}
/// <summary>
/// Combine the passed in environment object with the equivalent properties defined in the framework settings
/// (if present). Properties that already exist in the passed in the environment take precedence over the
/// properties defined in the framework settings.
/// </summary>
/// <param name="environment">Environment object to check.</param>
/// <param name="settings">Framework settings.</param>
/// <returns>Environment object with merged properties.</returns>
internal static Environment MergeWithSettings(Environment environment, IFrameworkSettings settings)
{
Environment merged;
if (environment == null)
{
merged = new Environment();
}
else
{
merged = environment;
}
if (merged.ApplicationInfo == null)
{
merged.ApplicationInfo = new ApplicationInfo();
}
if (String.IsNullOrWhiteSpace(merged.ApplicationInfo.ApplicationKey) && settings.ApplicationKey != null)
{
merged.ApplicationInfo.ApplicationKey = settings.ApplicationKey;
}
if (String.IsNullOrWhiteSpace(merged.ApplicationInfo.ApplicationKey))
{
throw new ArgumentException("An applicationKey must either be provided or defined in the Consumer Environment template.", "applicationKey");
}
if (String.IsNullOrWhiteSpace(merged.AuthenticationMethod) && settings.AuthenticationMethod != null)
{
merged.AuthenticationMethod = settings.AuthenticationMethod;
}
if (String.IsNullOrWhiteSpace(merged.ConsumerName) && settings.ConsumerName != null)
{
merged.ConsumerName = settings.ConsumerName;
}
if (String.IsNullOrWhiteSpace(merged.ApplicationInfo.DataModelNamespace) && settings.DataModelNamespace != null)
{
merged.ApplicationInfo.DataModelNamespace = settings.DataModelNamespace;
}
if (String.IsNullOrWhiteSpace(merged.ApplicationInfo.SupportedInfrastructureVersion) && settings.SupportedInfrastructureVersion != null)
{
merged.ApplicationInfo.SupportedInfrastructureVersion = settings.SupportedInfrastructureVersion;
}
return merged;
}
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);
}