/// <summary>
/// Updates (or adds) the HATEOAS configuration
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="hateoasConfiguration">HATEOAS configuration</param>
public static void UpdateConfiguration(this IHttpConfiguration configuration, IHateoasConfiguration hateoasConfiguration)
{
configuration.Properties.AddOrUpdate(
typeof(IHateoasConfiguration),
hateoasConfiguration,
(oldValue, newValue) => hateoasConfiguration);
}
public ConfigurationProvider(IHttpConfiguration httpConfiguration, ILinkFactory linkFactory, IConfigurationProviderGetLinksForFuncProvider linksForFuncProvider, ICache <Type, Func <ConfigurationProvider, object, IEnumerable <IHateoasLink> > > getLinksForMethodCache)
{
_httpConfiguration = httpConfiguration;
_linkFactory = linkFactory;
_linksForFuncProvider = linksForFuncProvider;
_getLinksForMethodCache = getLinksForMethodCache;
}
public ReliableRestClientRestSharPolly(IHttpConfiguration httpConfiguration) : base(httpConfiguration.BaseUrl)
{
_retryPolicy = Policy
.HandleResult <IRestResponse>(r => _httpStatusCodesWorthRetrying.Contains(r.StatusCode))
.WaitAndRetryAsync(_maxRetryCount,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
);
}
internal HateoasContainer(IHttpConfiguration httpConfiguration, HateoasConfiguration configuration)
{
Configuration = configuration;
//Registrations = new List<IHateoasRegistration>();
_httpConfiguration = httpConfiguration;
Update();
}
public HttpDataService(
IHttpConfiguration configuration,
IDataParser dataParser)
{
_dataParser = dataParser;
_http = new HttpClient
{
BaseAddress = configuration.BaseUri
};
}
/// <summary>
/// Uploads a file to the SystemLink server using an in-memory stream.
/// This allows the file to be created on the server without writing it
/// to disk first.
/// </summary>
/// <param name="configuration">The HTTP configuration to connect to the SystemLink server.</param>
/// <param name="fileName">The name for the uploaded file.</param>
/// <param name="fileContents">An array of bytes to send for the contents of the file.</param>
/// <returns>The ID of the file that was uploaded.</returns>
public static string UploadFileData(IHttpConfiguration configuration, string fileName, byte[] fileContents)
{
// Upload a file using the SystemLink File client
var fileUploader = new FileUploader(configuration);
// Use in-memory data for the file upload.
using (var memoryStream = new MemoryStream(fileContents))
{
// Upload the file to the SystemLink server and get the ID for the uploaded file.
var fileId = fileUploader.UploadFile(memoryStream, fileName);
return(fileId);
}
}
/// <summary>
/// Updates (or adds) an HATEOAS registration
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="registration">HATEOAS registration</param>
public static void UpdateRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration)
{
var definition = configuration.GetRegistrationFor(registration.Model, registration.Relation, registration.IsCollection);
if (definition == null)
{
configuration.AddRegistration(registration);
}
else
{
definition.Expression = registration.Expression;
}
}
/// <summary>
/// Returns the HATEOASregistration for a specific model and relation. Returns null when the combination of model and relation could not be found.
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="model">The model to get an HATEOAS registration for</param>
/// <param name="relation">Relation to the model</param>
/// <param name="isCollection">Indicates wether the source registration is s collection</param>
/// <returns>HATEOAS registration for the model and relation specified</returns>
public static IHateoasRegistration GetRegistrationFor(this IHttpConfiguration configuration, Type model, string relation, bool isCollection)
{
var definitions = configuration.GetRegistrationsFor(model);
var definition = definitions.SingleOrDefault(def => def.Model == model && def.Relation == relation && def.IsCollection == isCollection);
//if (definition == null)
//{
// // TODO Maybe implement AddOrUpdate behavior?
// throw new HateoasException($"No registration found for model {model} and relation {relation}");
//}
return(definition);
}
public static void Startup <TRegistrationClass>(
IHttpConfiguration configuration,
IAuthorizationProvider authorizationProvider = null,
IDependencyResolver dependencyResolver = null,
IList <IMessageSerializer> messageSerializers = null)
where TRegistrationClass : IHateoasRegistrationProfile, new()
{
Startup(
new TRegistrationClass(),
configuration,
authorizationProvider,
dependencyResolver,
messageSerializers);
}
/// <summary>
/// Returns the HATEOAS registrations for a specific model. Returns a (registered) empty list when the model could not be found.
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="model">The model to get HATEOAS registrations for</param>
/// <param name="isCollection"></param>
/// <returns>HATEOAS registrations for the model specified</returns>
public static List <IHateoasRegistration> GetRegistrationsFor(this IHttpConfiguration configuration, Type model)
{
var linkedResourceDefinitions = configuration.GetRegistrations();
List <IHateoasRegistration> definitions;
if (linkedResourceDefinitions.TryGetValue(model, out definitions))
{
return(definitions);
}
definitions = new List <IHateoasRegistration>();
linkedResourceDefinitions.Add(model, definitions);
return(definitions);
}
public static void Startup <TRegistrationClass>(
TRegistrationClass registrationClass,
IHttpConfiguration configuration,
IAuthorizationProvider authorizationProvider = null,
IDependencyResolver dependencyResolver = null,
IList <IMessageSerializer> messageSerializers = null)
where TRegistrationClass : IHateoasRegistrationProfile
{
var linkBuilderFactory = new LinkBuilderFactory();
// todo: this is not very clean; user dependencyresolver etc
if (authorizationProvider == null)
{
var httpContextWrapper = new HttpContextWrapper(HttpContext.Current);
authorizationProvider = new WebApiAuthorizationProvider(httpContextWrapper);
}
var idFromExpressionProcessor = new IdFromExpressionProcessor(dependencyResolver);
var argumentsDefinitionsProcessor = new ArgumentDefinitionsProcessor();
var templateArgumentsProcessor = new TemplateArgumentsProcessor();
var linkFactory = new LinkFactory(
linkBuilderFactory: linkBuilderFactory,
authorizationProvider: authorizationProvider,
idFromExpressionProcessor: idFromExpressionProcessor,
argumentsDefinitionsProcessor: argumentsDefinitionsProcessor,
templateArgumentsProcessor: templateArgumentsProcessor
);
var inMemoryGenericLinksForMethodsCache = new InMemoryCache <int, MethodInfo>();
var linksForFuncProvider =
new ConfigurationProviderGetLinksForFuncProvider(inMemoryGenericLinksForMethodsCache);
var getLinksForMethodCache =
new InMemoryCache <Type, Func <ConfigurationProvider, object, IEnumerable <IHateoasLink> > >();
var configurationProvider = new ConfigurationProvider(configuration, linkFactory, linksForFuncProvider,
getLinksForMethodCache);
var responseProvider = new ResponseProvider(configurationProvider);
var handler = new HateoasHttpHandler(responseProvider, messageSerializers ?? new List <IMessageSerializer>());
configuration.MessageHandlers.Add(handler);
var container = HateoasContainerFactory.Create(configuration);
registrationClass.Register(container);
}
private static void PublishMessages(IHttpConfiguration configuration)
{
/*
* Open a separate session for publishing messages. This is not
* required, but simulates how two separate applications can
* communicate with each other using messages.
*/
Console.WriteLine("Publishing messages...");
using (var writeSession = MessageSession.Open(configuration))
{
/*
* Messages can contain any string. It's up to the application
* to determine the data format to use for each message topic.
* In this example, the example.data topic contains a JSON
* representation of the MessageData class.
*/
var data = JsonConvert.SerializeObject(new MessageData
{
Message = "Hello World! PI=",
Value = Math.PI
});
writeSession.Publish("example.data", data);
data = JsonConvert.SerializeObject(new MessageData
{
Message = "Another message, E=",
Value = Math.E
});
writeSession.Publish("example.data", data);
/*
* The server will ignore messages published to a topic with no
* subscribers, but it's not an error.
*/
writeSession.Publish("example.unknown", "no subscribers");
/*
* Publish messages to the example.exit topic to signal the
* reader to stop. Both are queued, but only one is read.
*/
writeSession.Publish("example.exit", "first exit");
writeSession.Publish("example.exit", "second exit");
}
}
public WebApiImageService(IHttpConfiguration httpConfiguration) : base(httpConfiguration)
{
}
public static HateoasContainer Create(IHttpConfiguration configuration)
{
return(new HateoasContainer(configuration, new HateoasConfiguration()));
}
public WebApiAccountService(IHttpConfiguration httpConfiguration) : base(httpConfiguration)
{
}
protected HttpServiceBase(IHttpConfiguration httpConfiguration) => httpClient = new HttpClient
/// <summary>
/// Returns a dictionary holding all HATEOAS registrations.
/// </summary>
/// <param name="configuration">source paramater</param>
/// <returns>Dictionary holding all HATEOAS registrations</returns>
public static Dictionary <Type, List <IHateoasRegistration> > GetRegistrations(this IHttpConfiguration configuration)
{
return((Dictionary <Type, List <IHateoasRegistration> >)configuration.Properties.GetOrAdd(
typeof(Dictionary <Type, List <IHateoasRegistration> >),
k => new Dictionary <Type, List <IHateoasRegistration> >()
));
}
/// <summary>
/// Adds an HATEOAS registration
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="registration">HATEOAS registration</param>
public static void AddRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration)
{
var definitions = configuration.GetRegistrationsFor(registration.Model);
definitions.Add(registration);
}
/// <summary>
/// Returns the HATEOAS registrations for a specific model. Returns a (registered) empty list when the model could not be found.
/// </summary>
/// <param name="configuration">HTTP configuration</param>
/// <param name="model">The model to get HATEOAS registrations for</param>
/// <param name="isCollection"></param>
/// <returns>HATEOAS registrations for the model specified</returns>
public static List <IHateoasRegistration <TModel> > GetRegistrationsFor <TModel>(this IHttpConfiguration configuration)
{
return(configuration
.GetRegistrationsFor(typeof(TModel))
.Cast <IHateoasRegistration <TModel> >()
.ToList());
}
/// <summary>
/// Gets (or adds) the HATEOAS configuration
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public static IHateoasConfiguration GetConfiguration(this IHttpConfiguration configuration)
{
return((IHateoasConfiguration)configuration.Properties.GetOrAdd(typeof(IHateoasConfiguration), p => new HateoasConfiguration()));
}
