protected override Task <IResourceInfo> GetAsyncInternal(UriString uri, IImmutableSession metadata)
{
var(exists, values) = GetValues(uri);
var isCollection = uri.Query.TryGetValue(CommandArgumentQueryStringKeys.IsCollection, out var ic) && bool.Parse(ic.ToString());
return(Task.FromResult <IResourceInfo>(new CommandArgumentInfo(uri, exists, isCollection ? values : values.Take(1).ToList())));
}
public static async Task <IResourceInfo> SendEmailAsync
(
this IResourceProvider resourceProvider,
IEmail <IEmailSubject, IEmailBody> email,
IImmutableSession metadata = default
)
{
metadata =
(metadata ?? ImmutableSession.Empty)
.Set(Use <IMailNamespace> .Namespace, x => x.From, email.From)
.Set(Use <IMailNamespace> .Namespace, x => x.To, email.To)
.Set(Use <IMailNamespace> .Namespace, x => x.CC, email.CC)
.Set(Use <IMailNamespace> .Namespace, x => x.Subject, email.Subject.Value)
.Set(Use <IMailNamespace> .Namespace, x => x.Attachments, email.Attachments)
.Set(Use <IMailNamespace> .Namespace, x => x.From, email.From)
.Set(Use <IMailNamespace> .Namespace, x => x.IsHtml, email.IsHtml)
.Set(Use <IMailNamespace> .Namespace, x => x.IsHighPriority, email.IsHighPriority);
return(await resourceProvider.PostAsync
(
$"{MailProvider.DefaultScheme}:[email protected]",
() => ResourceHelper.SerializeTextAsync(email.Body.Value, email.Body.Encoding),
metadata
));
}
public CompositeProvider
(
[NotNull] IEnumerable <IResourceProvider> resourceProviders,
IImmutableSession metadata = default
)
: base(new[] { DefaultScheme }, metadata ?? ImmutableSession.Empty)
{
if (resourceProviders == null)
{
throw new ArgumentNullException(nameof(resourceProviders));
}
_cache = new Dictionary <SoftString, IResourceProvider>();
_resourceProviders = resourceProviders.ToImmutableList();
var duplicateProviderNames =
_resourceProviders
.Where(p => p.CustomName)
.GroupBy(p => p.CustomName)
.Where(g => g.Count() > 1)
.Select(g => g.First())
.ToList();
if (duplicateProviderNames.Any())
{
throw new ArgumentException
(
$"Providers must use unique custom names but there are some duplicates: " +
$"[{duplicateProviderNames.Select(p => (string)p.CustomName).Join(", ")}]."
);
}
}
public static async Task <string> SendAsync <TBody>
(
this IResourceProvider resourceProvider,
UriString uri,
Email <TBody> email,
string productName,
string productVersion,
[CanBeNull] JsonSerializer jsonSerializer = null,
[CanBeNull] IImmutableSession metadata = default
)
{
metadata =
(metadata ?? ImmutableSession.Empty)
.Set(Use <IHttpNamespace> .Namespace, x => x.ConfigureRequestHeaders, headers =>
{
headers
.UserAgent(productName, productVersion)
.AcceptHtml();
})
.Set(Use <IHttpNamespace> .Namespace, x => x.ResponseFormatters, new[] { new TextMediaTypeFormatter() })
.Set(Use <IHttpNamespace> .Namespace, x => x.ContentType, "application/json")
.Set(Use <IAnyNamespace> .Namespace, x => x.Schemes, ImmutableHashSet <SoftString> .Empty.Add("http").Add("https"))
// Bind this request to the http-provider.
.Set(Use <IProviderNamespace> .Namespace, x => x.DefaultName, nameof(HttpProvider));
using (var response = await resourceProvider.PostAsync(uri, () => ResourceHelper.SerializeAsJsonAsync(email, jsonSerializer), metadata))
{
return(await response.DeserializeTextAsync());
}
}
protected async Task <string> ReadBodyAsync(Stream value, IImmutableSession metadata)
{
using (var bodyReader = new StreamReader(value, metadata.Get(Use <IMailNamespace> .Namespace, x => x.BodyEncoding, Encoding.UTF8)))
{
return(await bodyReader.ReadToEndAsync());
}
}
protected override Task <IResourceInfo> GetAsyncInternal(UriString uri, IImmutableSession metadata)
{
var settingIdentifier = UriConverter?.Convert <string>(uri) ?? uri;
var exeConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var settings = FindConnectionStringSettings(exeConfig, settingIdentifier);
return(Task.FromResult <IResourceInfo>(new ConnectionStringInfo(uri, settings?.ConnectionString)));
}
public EmbeddedFileProvider([NotNull] Assembly assembly, IImmutableSession metadata = default)
: base((metadata ?? ImmutableSession.Empty).Set(Use <IProviderNamespace> .Namespace, x => x.AllowRelativeUri, true))
{
_assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
var assemblyName = _assembly.GetName().Name.Replace('.', '/');
BaseUri = new UriString($"{DefaultScheme}:{assemblyName}");
}
public static IImmutableSession WithRegexComparer(this IImmutableSession context)
{
return(context.WithComparer(GetComparerNameFromCaller(), EqualityComparerFactory <object> .Create
(
equals: (left, right) => Regex.IsMatch((string)right, (string)left, RegexOptions.None),
getHashCode: (obj) => 0
)));
}
public static IImmutableSession WithSoftStringComparer(this IImmutableSession context)
{
return(context.WithComparer(GetComparerNameFromCaller(), EqualityComparerFactory <object> .Create
(
equals: (left, right) => SoftString.Comparer.Equals((string)left, (string)right),
getHashCode: (obj) => SoftString.Comparer.GetHashCode((string)obj)
)));
}
protected override Task <IResourceInfo> GetAsyncInternal(UriString uri, IImmutableSession metadata)
{
var settingIdentifier = UriConverter?.Convert <string>(uri) ?? uri;
var exeConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var actualKey = FindActualKey(exeConfig, settingIdentifier) ?? settingIdentifier;
var element = exeConfig.AppSettings.Settings[actualKey];
return(Task.FromResult <IResourceInfo>(new AppSettingInfo(uri, element?.Value, ImmutableSession.Empty.Set(Use <IResourceNamespace> .Namespace, x => x.ActualName, settingIdentifier))));
}
private Exception WrapException(UriString uri, IImmutableSession metadata, Exception inner, [CallerMemberName] string memberName = null)
{
throw DynamicException.Create
(
ExtractMethodName(memberName),
Because(memberName, uri, "of an error. See inner exception for details."),
inner
);
}
public static IImmutableSession WithReferences(this IImmutableSession context, IEnumerable <IExpression> expressions)
{
var registrations =
context
.Get(Expression.Namespace, x => x.References, ImmutableDictionary <SoftString, IExpression> .Empty)
.SetItems(expressions.Select(e => new KeyValuePair <SoftString, IExpression>($"R.{e.Name.ToString()}", e)));
return(context.Set(Expression.Namespace, x => x.References, registrations));
}
public static IImmutableSession WithComparer(this IImmutableSession context, string name, IEqualityComparer <object> comparer)
{
var comparers =
context
.Get(Expression.Namespace, x => x.Comparers, ImmutableDictionary <SoftString, IEqualityComparer <object> > .Empty)
.SetItem(name, comparer);
return(context.Set(Expression.Namespace, x => x.Comparers, comparers));
}
public static async Task <IResourceInfo> PostAsync
(
this IResourceProvider resourceProvider,
UriString uri,
Func <Task <Stream> > serializeAsync,
IImmutableSession metadata = default
)
{
return(await ExecuteAsync(resourceProvider.PostAsync, uri, serializeAsync, metadata));
}
public async Task <IResourceInfo> DeleteAsync(UriString uri, IImmutableSession metadata = default)
{
ValidateRequest(ExtractMethodName(nameof(GetAsync)), uri, metadata ?? ImmutableSession.Empty, Stream.Null, RequestValidator);
try
{
return(await DeleteAsyncInternal(uri, metadata));
}
catch (Exception inner)
{
throw WrapException(uri, metadata, inner);
}
}
public HttpProvider([NotNull] string baseUri, IImmutableSession metadata = default)
: base(new SoftString[] { "http", "https" }, (metadata ?? ImmutableSession.Empty).Set(Use <IProviderNamespace> .Namespace, x => x.AllowRelativeUri, true))
{
if (baseUri == null)
{
throw new ArgumentNullException(nameof(baseUri));
}
_client = new HttpClient
{
BaseAddress = new Uri(baseUri)
};
_client.DefaultRequestHeaders.Clear();
}
protected override Task <IResourceInfo> GetAsyncInternal(UriString uri, IImmutableSession metadata)
{
//ValidateFormatNotNull(this, uri, metadata);
// Embedded resource names are separated by '.' so replace the windows separator.
var fullUri = BaseUri + uri;
var fullName = fullUri.Path.Decoded.ToString().Replace('/', '.');
// Embedded resource names are case sensitive so find the actual name of the resource.
var actualName = _assembly.GetManifestResourceNames().FirstOrDefault(name => SoftString.Comparer.Equals(name, fullName));
var getManifestResourceStream = actualName is null ? default(Func <Stream>) : () => _assembly.GetManifestResourceStream(actualName);
return(Task.FromResult <IResourceInfo>(new EmbeddedFileInfo(fullUri, metadata.Get(Use <IResourceNamespace> .Namespace, y => y.Format), getManifestResourceStream)));
}
protected void ValidateRequest(string method, UriString uri, IImmutableSession metadata, Stream stream, params IExpressValidator <Request>[] validators)
{
var request = new Request
{
Method = method,
Provider = this,
Uri = uri,
Metadata = metadata,
Stream = default
};
foreach (var validator in validators)
{
validator.Validate(request).Assert();
}
}
public static async Task <T> Deserialize <T>(Stream value, IImmutableSession metadata)
{
var format = metadata.Get(Use <IResourceNamespace> .Namespace, x => x.Format);
if (format == MimeType.Text)
{
return((T)(object) await DeserializeTextAsync(value));
}
if (format == MimeType.Binary)
{
return((T) await DeserializeBinaryAsync <object>(value));
}
throw DynamicException.Create("Format", $"Unsupported value format: '{format}'.");
}
//
// public static T GetItemByCallerName<T>([NotNull] this IImmutableSession metadata, T defaultValue = default, [CallerMemberName] string key = null)
// {
// if (metadata == null) throw new ArgumentNullException(nameof(metadata));
//
// return
// // ReSharper disable once AssignNullToNotNullAttribute - 'key' isn't null
// metadata.TryGetValue(key, out T value)
// ? value
// : defaultValue;
// }
public static bool TryGetValue <T>([NotNull] this IImmutableSession metadata, [NotNull] SoftString key, [CanBeNull] out T value)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
if (metadata.TryGetValue(key, out var x) && x is T result)
{
value = result;
return(true);
}
else
{
value = default;
return(false);
}
}
protected ResourceInfo
(
[NotNull] UriString uri,
[NotNull] IImmutableSession metadata
)
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
Uri = uri.IsRelative ? new UriString($"{ResourceProvider.DefaultScheme}:{uri}") : uri;
Metadata = metadata;
}
protected ResourceProvider([NotNull] IEnumerable <SoftString> schemes, IImmutableSession metadata)
{
if (schemes == null)
{
throw new ArgumentNullException(nameof(schemes));
}
//var metadata = Metadata.Empty;
// If this is a decorator then the decorated resource-provider already has set this.
if (metadata.Get(Use <IProviderNamespace> .Namespace, x => x.DefaultName) is var df && !df)
{
metadata = metadata.Set(Use <IProviderNamespace> .Namespace, x => x.DefaultName, GetType().ToPrettyString());
}
if ((Schemes = schemes.ToImmutableHashSet()).Empty())
{
throw new ArgumentException(paramName: nameof(metadata), message: $"{nameof(schemes)} must not be empty.");
}
Metadata = metadata;
}
private static async Task <IResourceInfo> ExecuteAsync
(
Func <UriString, Stream, IImmutableSession, Task <IResourceInfo> > executeAsync,
UriString uri,
Func <Task <Stream> > serializeAsync,
IImmutableSession metadata
)
{
var stream = await serializeAsync();
var post = executeAsync(uri, stream, metadata);
await post.ContinueWith(t =>
{
stream.Dispose();
if (t.IsFaulted && t.Exception != null)
{
throw t.Exception;
}
});
return(await post);
}
protected virtual Task <IResourceInfo> DeleteAsyncInternal(UriString uri, IImmutableSession metadata) => throw MethodNotSupportedException(uri);
public Constant(SoftString name, TValue value, IImmutableSession context = default)
: base(ZeroLogger.Default, name ?? value.GetType().ToPrettyString())
{
Value = value;
Context = context ?? ImmutableSession.Empty;
}
public static IImmutableSession ThisOrEmpty(this IImmutableSession session) => session ?? ImmutableSession.Empty;
protected override Task <IResourceInfo> DeleteAsyncInternal(UriString uri, IImmutableSession metadata)
{
return(_resourceProvider.DeleteAsync(Combine(uri), metadata));
}
protected override Task <IResourceInfo> PutAsyncInternal(UriString uri, Stream value, IImmutableSession metadata)
{
return(_resourceProvider.PutAsync(Combine(uri), value, metadata));
}
protected override async Task <IResourceInfo> GetAsyncInternal(UriString uri, IImmutableSession metadata)
{
return(await _resourceProvider.GetAsync(Combine(uri), metadata));
}
internal SqlServerResourceInfo([NotNull] UriString uri, [CanBeNull] object value, IImmutableSession metadata)
: base(uri, metadata.Set(Use <IResourceNamespace> .Namespace, x => x.Format, value is string?MimeType.Text: MimeType.Binary))
{
_value = value;
}
