private Exception MethodNotSupportedException(UriString uri, [CallerMemberName] string memberName = null) { return(DynamicException.Create ( $"{ExtractMethodName(memberName)}NotSupported", Because(memberName, uri, "it doesn't support it.") )); }
private static T SafeCast(object obj) { return (obj is null ? default : obj is T parameter ? parameter : throw DynamicException.Create("CommandParameterType", $"Could not cast '{obj.GetType().ToPrettyString()}' to '{typeof(T).ToPrettyString()}'.")); }
private static Type ValidateIsAnonymous(this Type type) { var isAnonymous = type.Name.StartsWith("<>f__AnonymousType"); return (isAnonymous ? type : throw DynamicException.Create("Snapshot", "Snapshot must be either an anonymous type of a dictionary")); }
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 ); }
private IEnumerable <T> Merge <T>(TestBundle testBundle, IEnumerable <TestBundle> partials, Func <TestBundle, IEnumerable <T> > selectMergeables) where T : class, IMergeable { var mergeables = selectMergeables(testBundle); foreach (var mergeable in mergeables) { if (mergeable.Merge is null) { yield return(mergeable); continue; } var merge = mergeable.Merge; var otherTestBundle = partials.SingleOrDefault(p => p.Name == merge.OtherFileName) ?? throw DynamicException.Create("OtherTestBundleNotFound", $"Could not find test bundle '{merge.OtherFileName}'."); var otherMergeables = selectMergeables(otherTestBundle).SingleOrDefault(x => x.Id == merge.OtherId) ?? throw DynamicException.Create("OtherMergeableNotFound", $"Could not find mergeable '{merge.OtherId}'."); var(first, second) = (mergeable, otherMergeables); var merged = (IMergeable)_componentContext.Resolve(mergeable.GetType()); merged.Id = mergeable.Id; merged.Merge = mergeable.Merge; var mergeableProperties = merged.GetType().GetProperties().Where(p => p.IsDefined(typeof(MergableAttribute))); foreach (var property in mergeableProperties) { var firstValue = property.GetValue(first); var newValue = property.GetValue(second); switch (firstValue) { case IEnumerable <SoftString> x when newValue is IEnumerable <SoftString> y: newValue = x.Union(y).ToList(); break; case IEnumerable <KeyValuePair <SoftString, object> > x when newValue is IEnumerable <KeyValuePair <SoftString, object> > y: newValue = x.Union(y).ToDictionary(p => p.Key, p => p.Value); break; } if (property.GetCustomAttribute <MergableAttribute>().Required&& newValue is null) { throw DynamicException.Create( "MissingValue", $"You need to specify a value for '{property.Name}' in '{testBundle.FileName}'. Either directly or via a merge." ); } property.SetValue(merged, newValue); } yield return((T)merged); } }
private static string GetMemberName(LambdaExpression xItem) { return (xItem.Body is MemberExpression me ? me.Member.Name : throw DynamicException.Create ( $"NotMemberExpression", $"Cannot use expression '{xItem}' because Get/Set expression must be member-expressions." )); }
public async Task ExecuteAsync <TContext>(string commandLineString, TContext context, CancellationToken cancellationToken) { if (commandLineString.IsNullOrEmpty()) { throw DynamicException.Create("CommandLineNullOrEmpty", "You need to specify at least one command."); } var commandLines = _commandLineParser.Parse(commandLineString); await ExecuteAsync(commandLines, context, cancellationToken); }
private static Type ValidateHasNoGenericArguments(this Type type) { return (type.GenericTypeArguments.Any() ? throw DynamicException.Create ( "GenericTypeArguments", "You must not specify generic type arguments explicitly. Leave them empty, e.g. 'List<>' or 'Dictionary<,>'" ) : type); }
private IConsoleCommand GetCommand(Identifier id) { return (_commands.TryGetValue(id, out var command) ? command : throw DynamicException.Create ( $"CommandNotFound", $"Could not find command '{id.Default.ToString()}'." )); }
public override void OnActionExecuting(ActionExecutingContext context) { var emailMetadata = context.ActionArguments.Values.OfType <IEmailMetadata>().SingleOrDefault(); if (emailMetadata is null) { throw DynamicException.Create("EmailArgumentNotFound", $"Could not read the email metadata for '{context.HttpContext.Request.Path.Value}'. This might be due to an invalid model."); } context.HttpContext.Items[EmailMetadata] = emailMetadata; }
public static IContentAssert <JToken> HasProperty(this IContentAssert <JToken> content, string jsonPath) { if (content.Value is null) { throw DynamicException.Create("ContentNull", "There is no content."); } return (content.Value.SelectToken(jsonPath) != null ? content : throw DynamicException.Create("ContentPropertyNotFound", $"There is no such property as '{jsonPath}'")); }
protected override Constant <IExpression> InvokeCore() { var expressions = Scope.Context.Get(Namespace, x => x.References); var path = Path.StartsWith("R.", StringComparison.OrdinalIgnoreCase) ? Path : $"R.{Path}"; if (expressions.TryGetValue(path, out var expression)) { return(Path, expression); } else { throw DynamicException.Create("RefNotFound", $"Could not find a reference to '{path}'."); } }
public static IContentAssert <JValue> Value(this IContentAssert <JToken> content, string jsonPath) { if (content.Value is null) { throw DynamicException.Create("ContentNull", "There is no content."); } return (content.Value.SelectToken(jsonPath) is JValue value ? new ContentAssert <JValue>(value) { Path = jsonPath } : throw DynamicException.Create("ContentPropertyNotFound", $"There is no such property as '{jsonPath}'")); }
// key.Property.Property --> session[key].Property.Property // this.Property.Property --> @this.Property.Property protected object FindItem(Func <string, string> configurePath = default) { var names = Path.Split('.'); var key = names.First(); var obj = key == "this" ? Scope.Context.Get(Namespace, x => x.This) : Scope.Context.TryGetValue(key, out var item) ? item : throw DynamicException.Create("ItemNotFound", $"Could not find an item with the key '{Path}'."); obj = names.Skip(1).Aggregate(obj, (current, name) => current.GetType().GetProperty(name).GetValue(current)); return(obj); }
private async Task <(Stream Content, string MimeType)> InvokeAsync(UriString uri, HttpMethod method, IImmutableSession metadata) { using (var request = new HttpRequestMessage(method, uri)) { var content = metadata.Get(Use <IHttpNamespace> .Namespace, x => x.Content); if (content != null) { request.Content = new StreamContent(content.Rewind()); request.Content.Headers.ContentType = new MediaTypeHeaderValue(metadata.Get(Use <IHttpNamespace> .Namespace, x => x.ContentType)); } Metadata.Get(Use <IHttpNamespace> .Namespace, x => x.ConfigureRequestHeaders, _ => { })(request.Headers); metadata.Get(Use <IHttpNamespace> .Namespace, x => x.ConfigureRequestHeaders)(request.Headers); using (var response = await _client.SendAsync(request, HttpCompletionOption.ResponseContentRead, metadata.Get(Use <IAnyNamespace> .Namespace, x => x.CancellationToken))) { var responseContentCopy = new MemoryStream(); if (response.Content.Headers.ContentLength > 0) { await response.Content.CopyToAsync(responseContentCopy); } var clientErrorClass = new Range <int>(400, 499); var serverErrorClass = new Range <int>(500, 599); var classOfStatusCode = clientErrorClass.ContainsInclusive((int)response.StatusCode) ? "Client" : serverErrorClass.ContainsInclusive((int)response.StatusCode) ? "Server" : null; if (classOfStatusCode is null) { return(responseContentCopy, response.Content.Headers.ContentType.MediaType); } using (var responseReader = new StreamReader(responseContentCopy.Rewind())) { throw DynamicException.Create ( classOfStatusCode, $"StatusCode: {(int)response.StatusCode} ({response.StatusCode}){Environment.NewLine}{await responseReader.ReadToEndAsync()}" ); } } } }
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 async Task <(DataTable Data, string Query)> GetDataAsync(string path, IRuntimeFormatter formatter) { Debug.Assert(!(formatter is null)); var connectionString = ConnectionString.FormatWith(formatter); var query = GetQuery(path, formatter); var scope = Logger.BeginScope().AttachElapsed(); try { Logger.Log(Abstraction.Layer.Database().Composite(new { properties = new { connectionString, query } })); using (var conn = new SqlConnection(connectionString)) { conn.Open(); using (var cmd = conn.CreateCommand()) { cmd.CommandText = query; cmd.CommandType = CommandType.Text; using (var dataReader = await cmd.ExecuteReaderAsync()) { var dataTable = new DataTable(); dataTable.Load(dataReader); EvaluateAttachments(dataTable); Logger.Log(Abstraction.Layer.Database().Meta(new { DataTable = new { RowCount = dataTable.Rows.Count, ColumnCount = dataTable.Columns.Count } })); Logger.Log(Abstraction.Layer.Database().Routine(nameof(GetDataAsync)).Completed()); return(dataTable, query); } } } } catch (Exception ex) { throw DynamicException.Create("DataSource", $"Unable to get data for {Id}.", ex); } finally { scope.Dispose(); } }
private static IEqualityComparer <T> Create() { var equalityProperties = ( from property in typeof(T).GetPropertiesMany(BindingFlags.Public | BindingFlags.Instance) where property.IsDefined(typeof(AutoEqualityPropertyAttribute)) let attribute = property.GetCustomAttribute <AutoEqualityPropertyAttribute>() select(property, attribute) ).ToList(); if (equalityProperties.Empty()) { throw DynamicException.Create("AutoEqualityPropertyNotFound", $"Could not find any '{nameof(AutoEqualityPropertyAttribute)}' on '{typeof(T).ToPrettyString()}'"); } return(Create(equalityProperties)); }
public static T ThrowIfInvalid <T>([NotNull] this BouncerPolicyCheckLookup <T> checkLookup) { if (checkLookup == null) { throw new ArgumentNullException(nameof(checkLookup)); } return (checkLookup ? checkLookup : throw DynamicException.Create ( $"{typeof(T).ToPrettyString()}Validation", $"Object does not meet one or more requirements.{Environment.NewLine}{Environment.NewLine}" + $"{checkLookup[false].Select(Func.ToString).Join(Environment.NewLine)}" )); }
public ResponseInfo Next(HttpRequest request) { while (_responses.Any()) { var next = _responses.Peek(); var response = next(request); if (response is null) { _responses.Dequeue(); } else { return(response); } } throw DynamicException.Create("OutOfResponses", "There are not more responses"); }
/// <summary> /// Gets the value of a Constant expression if it's of the specified type T or throws an exception. /// </summary> public static T Value <T>(this IConstant constant) { if (typeof(T) == typeof(object)) { return((T)constant.Value); } else { return (constant.Value is T value ? value : throw DynamicException.Create ( "ValueType", $"Expected {typeof(Constant<T>).ToPrettyString()} but found {constant.GetType().ToPrettyString()}." )); } }
protected override Constant <object> InvokeCore() { using (var e = Body.GetEnumerator()) { if (!e.MoveNext()) { throw DynamicException.Create("EmptyBlockBody", "Block's Body has to contain at least one element."); } var last = e.Current.Invoke(); while (e.MoveNext()) { last = e.Current.Invoke(); } return(last.Name, last.Value); } }
private static object[] CreateDataItem(MethodInfo testMethod, object item) { var itemProperties = item.GetType().GetProperties().ToDictionary(p => p.Name, p => p, SoftString.Comparer); var testMethodParameters = testMethod.GetParameters(); var dataItem = new object[testMethodParameters.Length]; // We need the index to set the correct item in the result array. foreach (var(testMethodParameter, i) in testMethodParameters.Select((x, i) => (x, i))) { if (itemProperties.TryGetValue(testMethodParameter.Name, out var itemProperty)) { if (testMethodParameter.ParameterType.IsAssignableFrom(itemProperty.PropertyType)) { dataItem[i] = itemProperty.GetValue(item); } else { throw DynamicException.Create ( $"ParameterTypeMismatch", $"Cannot assign value of type '{itemProperty.PropertyType.ToPrettyString()}' " + $"to the parameter '{testMethodParameter.Name}' of type '{testMethodParameter.ParameterType.ToPrettyString()}'." ); } } else { if (testMethodParameter.IsOptional) { dataItem[i] = testMethodParameter.DefaultValue; } else { throw DynamicException.Create ( $"ParameterNotOptional", $"Data item does not specify the required parameter '{testMethodParameter.Name}'." ); } } } return(dataItem); }
public object Deserialize(object value, Type targetType) { if (value == null) { throw new ArgumentNullException(nameof(value)); } try { return (value.GetType() == targetType ? value : DeserializeCore(value, targetType)); } catch (Exception ex) { throw DynamicException.Create(nameof(Deserialize), Format($"Error converting '{value.GetType()}' to '{targetType}'. See the inner exception for details.", TypeFormatProvider.Default), ex); } }
public CommandRegistrationBuilder Add <TCommand>(Action <CommandRegistration> customize = default) where TCommand : IConsoleCommand { try { var registration = new CommandRegistration(_parameterConverter, typeof(TCommand), CommandHelper.GetCommandId(typeof(TCommand))); customize?.Invoke(registration); _commands.Add(registration); return(this); } catch (Exception inner) { throw DynamicException.Create ( $"RegisterCommand", $"An error occured while trying to register '{typeof(TCommand).ToPrettyString()}'. See the inner-exception for details.", inner ); } }
protected override object[] ConvertDataItem(MethodInfo testMethod, object item) { try { return(CreateDataItem(testMethod, item)); } catch (Exception inner) { throw DynamicException.Create ( $"DataItemConversion", $"Could not convert '{item.GetType().ToPrettyString()}' for '{GetTestMethodInfo()}'. See the inner exception for details.", inner ); } // Creates text: MyTest.TestMethod string GetTestMethodInfo() => $"{testMethod.DeclaringType.ToPrettyString()}.{testMethod.Name}"; }
public static async Task <T> GetItemAsync <T>(this IResourceProvider resources, UriString uri, IImmutableSession metadata = default) { using (var item = await resources.GetAsync(uri, metadata)) { var itemFormat = item.Metadata.Get(Use <IResourceNamespace> .Namespace, x => x.Format); if (item.Exists) { using (var memoryStream = new MemoryStream()) { await item.CopyToAsync(memoryStream); if (itemFormat == MimeType.Text) { using (var streamReader = new StreamReader(memoryStream.Rewind())) { return((T)(object)await streamReader.ReadToEndAsync()); } } if (itemFormat == MimeType.Binary) { return((T)await ResourceHelper.DeserializeBinaryAsync <object>(memoryStream.Rewind())); } } throw DynamicException.Create ( $"ItemFormat", $"Item's '{uri}' format is '{itemFormat}' but only '{MimeType.Binary}' and '{MimeType.Text}' are supported." ); } else { throw DynamicException.Create ( $"ItemNotFound", $"Could not find '{uri}' that maps to '{item.Metadata.Get(Use<IResourceNamespace>.Namespace, x => x.ActualName) ?? "N/A"}'." ); } } }
public static Merge Parse(string merge) { // _Global/301?base //var joinTypes = Enum.GetNames(typeof(JoinType)).Join("|"); //var mergeMatch = Regex.Match(merge, $"(?<otherFileName>[_a-z]+)\\/(?<otherId>\\d+)\\?(?<type>{joinTypes})", RegexOptions.IgnoreCase); var mergeMatch = Regex.Match(merge, $"(?<otherFileName>[_a-z0-9-]+)\\/(?<otherId>[_a-z0-9-]+)", RegexOptions.IgnoreCase); if (!mergeMatch.Success) { throw DynamicException.Create($"InvalidMergeExpression", $"{merge.QuoteWith("'")} is not a valid merge expression. Expected: 'Name/Id'."); } return(new Merge ( mergeMatch.Groups["otherFileName"].Value, mergeMatch.Groups["otherId"].Value //(JoinType)Enum.Parse(typeof(JoinType), mergeMatch.Groups["type"].Value, ignoreCase: true) )); }
private IEnumerable <(IConsoleCommand Command, ICommandLine CommandLine)> GetCommands(IEnumerable <ICommandLine> commandLines) { return(commandLines.Select((commandLine, i) => { try { var commandName = commandLine.CommandId(); return (GetCommand(commandName), commandLine); } catch (DynamicException inner) { throw DynamicException.Create ( $"CommandLine", $"Command line at {i} is invalid. See the inner-exception for details.", inner ); } })); }
public static T SingleOrThrow <T>([NotNull] this IEnumerable <T> source, Func <T, bool> predicate, Func <Exception> onEmpty = null, Func <Exception> onMultiple = null) { if (source == null) { throw new ArgumentNullException(nameof(source)); } var result = default(T); var count = 0; using (var enumerator = source.GetEnumerator()) { while (enumerator.MoveNext()) { if (predicate(enumerator.Current)) { if (++count > 1) { throw onMultiple?.Invoke() ?? DynamicException.Create ( $"{source.GetType().ToPrettyString()}ContainsMoreThanOneElement", $"There is more than one element that matches the specified predicate." ); } result = enumerator.Current; } } } if (count == 0) { throw onEmpty?.Invoke() ?? DynamicException.Create ( $"{source.GetType().ToPrettyString()}Empty", $"There is no element that match the specified predicate." ); } return(result); }