private Task HandleExceptionAsync(HttpContext context, Exception ex)
{
_logger.LogError(
$"Error while processing request {context.Request.Method} {context.Request.Path}: {ex.Message}");
if (ex is AutoMapperMappingException mappingException && mappingException.InnerException != null)
{
ex = mappingException.InnerException;
}
var code = ex switch
{
ArgumentException _ => HttpStatusCode.BadRequest,
BadDataException _ => HttpStatusCode.BadRequest,
DataChangedException _ => HttpStatusCode.BadRequest,
ForbiddenException _ => HttpStatusCode.Forbidden,
InfrastructureException _ => HttpStatusCode.InternalServerError,
InvalidDataException _ => HttpStatusCode.BadRequest,
NotFoundException _ => HttpStatusCode.NotFound,
UnauthorizedException _ => HttpStatusCode.Unauthorized,
_ => HttpStatusCode.InternalServerError
};
var result = JsonSerializer.Serialize(new { error = ex.Message });
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)code;
return(context.Response.WriteAsync(result));
}
}
protected override IPaymentResult PerformProcessPayment(SalePreparationBase preparation, IPaymentMethod paymentMethod)
{
// We have to use the CheckoutConfirmationModel in this implementation. If this were to be used
// outside of a demo, you could consider writing your own base controller that inherits directly from
// Merchello.Web.Mvc.PaymentMethodUiController<TModel> and complete the transaction there in which case the
// BazaarPaymentMethodFormControllerBase would be a good example.
var form = UmbracoContext.HttpContext.Request.Form;
var purchaseOrderNumber = form.Get("purchaseOrderNumber");
if (string.IsNullOrEmpty(purchaseOrderNumber))
{
var invalidData = new InvalidDataException("The Purchase Order Number cannot be an empty string");
return(new PaymentResult(Attempt <IPayment> .Fail(invalidData), null, false));
}
// You need a ProcessorArgumentCollection for this transaction to store the payment method nonce
// The braintree package includes an extension method off of the ProcessorArgumentCollection - SetPaymentMethodNonce([nonce]);
var args = new ProcessorArgumentCollection();
args.SetPurchaseOrderNumber(purchaseOrderNumber);
// We will want this to be an Authorize(paymentMethod.Key, args);
// -- Also in a real world situation you would want to validate the PO number somehow.
return(preparation.AuthorizePayment(paymentMethod.Key, args));
}
/// <summary>
/// Creates a new view.
/// </summary>
/// <param name="fileName">
/// The file name.
/// </param>
/// <param name="viewType">
/// The view type.
/// </param>
/// <param name="modelName">
/// The model name.
/// </param>
/// <param name="viewBody">
/// The view body.
/// </param>
/// <returns>
/// A value indicating whether or not the create was successful.
/// </returns>
public override PluginViewEditorContent CreateNewView(string fileName, PluginViewType viewType, string modelName, string viewBody)
{
var virtualPath = GetVirtualPathByPlugViewType(viewType);
var mapped = EnsureMappedPath(virtualPath);
fileName = fileName.Replace(" ", string.Empty);
var fullFileName = string.Format("{0}{1}", mapped, fileName);
if (!File.Exists(fullFileName))
{
using (var sw = File.CreateText(fullFileName))
{
sw.WriteLine("@inherits Merchello.Web.Mvc.MerchelloHelperViewPage<{0}>", modelName);
sw.WriteLine("@using Merchello.Core");
sw.WriteLine("@using Merchello.Core.Models");
sw.WriteLine("@*");
sw.WriteLine(" MerchelloHelperViewPage<T> inherits from UmbracoViewPage<t> and exposes the MerchelloHelper as 'Merchello'");
sw.WriteLine(" Example usage: var product = Merchello.TypedProductContent(YOURPRODUCTKEY);");
sw.WriteLine("*@");
sw.Close();
}
return(GetView(virtualPath, fileName, viewType));
}
var logData = MultiLogger.GetBaseLoggingData();
var ex = new InvalidDataException("File already exists");
MultiLogHelper.Error <PluginViewEditorProvider>("Cannot create a duplicate file", ex, logData);
throw ex;
}
protected Exception CreateException(InvalidDataException innerException)
{
string framingError = Resources.FramingError;
object[] streamPosition = new object[] { this.StreamPosition, this.CurrentStateAsString };
return(new ProtocolException(Microsoft.ServiceBus.SR.GetString(framingError, streamPosition), innerException));
}
public void InvalidData()
{
var exception = new InvalidDataException();
var observedExitCode = ExitCodeUtilities.ShowException(exception);
Assert.Equal((int)ExitCodes.InvalidData, observedExitCode);
}
private void OnNewDataAvailable(byte[] frame)
{
ArrayList data = new ArrayList(frame);
do
{
try
{
SPPMessage msg = SPPMessage.DecodeMessage(data.OfType <byte>().ToArray());
MessageReceived?.Invoke(this, msg);
if (msg.TotalPacketSize >= data.Count)
{
break;
}
data.RemoveRange(0, msg.TotalPacketSize);
}
catch (InvalidDataException e)
{
InvalidDataException?.Invoke(this, e);
}
} while (data.Count > 0);
NewDataAvailable?.Invoke(this, frame);
}
protected override Exception OnSizeQuotaExceeded(int size)
{
Exception result = new InvalidDataException(SR.Format(SR.FramingViaTooLong, size));
FramingEncodingString.AddFaultString(result, FramingEncodingString.ViaTooLongFault);
return(result);
}
public static void MessageConstructor()
{
string message = "MessageConstructor";
InvalidDataException ide = new InvalidDataException(message);
Assert.Equal(message, ide.Message);
}
public static void MessageConstructor()
{
string message = "MessageConstructor";
InvalidDataException ide = new InvalidDataException(message);
Assert.Equal(message, ide.Message);
}
public async Task GivenThatABaseUriChangesVerifyValidationFails()
{
using (var target = new TestFolder())
using (var cache = new LocalCache())
{
var log = new TestLogger();
var settings = new LocalSettings();
var fileSystem1 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root), UriUtility.CreateUri("https://tempuri.org/"));
var fileSystem2 = new PhysicalFileSystem(cache, UriUtility.CreateUri(target.Root), UriUtility.CreateUri("https://tempuri.org/b/"));
await InitCommand.RunAsync(settings, fileSystem1, log);
await SourceUtility.EnsureBaseUriMatchesFeed(fileSystem1, log, CancellationToken.None);
InvalidDataException foundEx = null;
try
{
await SourceUtility.EnsureBaseUriMatchesFeed(fileSystem2, log, CancellationToken.None);
}
catch (InvalidDataException ex)
{
foundEx = ex;
}
foundEx.Message.Should().Contain("https://tempuri.org/");
}
}
/// <summary>
/// Throws an invalid data exception
/// </summary>
/// <param name="reason">The reason for the exception</param>
public static void ThrowInvalidDataException(string reason)
{
var e = new InvalidDataException(reason);
ExceptionUtility.TraceException(e);
throw e;
}
public static T FromJson <T>(string json)
{
if (typeof(T).IsPrimitive || typeof(T) == typeof(string))
{
return((T)Convert.ChangeType(json, typeof(T)));
}
T instance;
try
{
instance = JsonConvert.DeserializeObject <T>(json);
}
catch (JsonReaderException)
{
json = EscapeDoubleQuotesInJsonPropertyValues(json);
instance = JsonConvert.DeserializeObject <T>(json);
Device.BeginInvokeOnMainThread(() =>
{
var ex = new InvalidDataException("Double quotes in json property value detected");
ex.Data.Add("Json", json);
MessagingCenter.Send(Application.Current, MessageTypes.ExceptionOccurred, ex);
});
}
return(instance);
}
public async Task ReadCsvFile(BufferBlock <string> queue, string filename)
{
// Use HashSet to avoid duplicated data which can produce errors in further work.
var result = new HashSet <string>();
using (var reader = new StreamReader(filename))
{
var csv = new CsvReader(
reader, new CsvHelper.Configuration.Configuration {
HasHeaderRecord = true
}
);
if (!csv.Read() || !csv.ReadHeader())
{
var ex = new InvalidDataException("CSV file doesn't contain header!");
_logger.Error(ex, "Got CSV file without header.");
throw ex;
}
while (csv.Read())
{
string thingName = csv[_thingNameHeader];
if (result.Add(thingName))
{
await queue.SendAsync(thingName);
}
}
}
}
/// <summary>
/// Verifies that the file can be written safely.
/// </summary>
public override bool Validate(out Exception ex)
{
if (!(Version == 101 || Version == 102 || Version == 103 || Version == 104 || Version == 201))
{
ex = new InvalidDataException($"Unknown version: {Version}");
return(false);
}
if (!ValidateNull(ParamType, $"{nameof(ParamType)} may not be null.", out ex) ||
!ValidateNull(Fields, $"{nameof(Fields)} may not be null.", out ex))
{
return(false);
}
for (int i = 0; i < Fields.Count; i++)
{
Field field = Fields[i];
string which = $"{nameof(Fields)}[{i}]";
if (!ValidateNull(field, $"{which}: {nameof(Field)} may not be null.", out ex) ||
!ValidateNull(field.DisplayName, $"{which}: {nameof(Field.DisplayName)} may not be null.", out ex) ||
!ValidateNull(field.DisplayFormat, $"{which}: {nameof(Field.DisplayFormat)} may not be null.", out ex) ||
!ValidateNull(field.InternalType, $"{which}: {nameof(Field.InternalType)} may not be null.", out ex) ||
Version >= 102 && !ValidateNull(field.InternalName, $"{which}: {nameof(Field.InternalName)} may not be null on version {Version}.", out ex))
{
return(false);
}
}
ex = null;
return(true);
}
public static async Task <TObject> Deserialize <TObject>(this HttpResponseMessage response, JsonSerializer jsonSerializer = null) where TObject : class
{
jsonSerializer ??= _serializer;
await ThrowIfNotSuccess(response).ConfigureAwait(false);
using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
using (var sr = new StreamReader(stream))
using (var jsonTextReader = new JsonTextReader(sr))
{
try
{
return(jsonSerializer.Deserialize <TObject>(jsonTextReader));
}
catch (Exception ex)
{
var exception = new InvalidDataException("failed to deserialize response", ex);
string rawResponse = null;
try
{
stream.Position = 0;
rawResponse = await sr.ReadLineAsync().ConfigureAwait(false);
exception.Data.Add("rawResponse", rawResponse);
}
catch { }
throw exception;
}
}
}
private void InstanceOnInvalidDataException(object sender, InvalidDataException e)
{
Dispatcher.Invoke(() =>
{
_popupShownCurrentSession = false;
if (_mainPage == null)
{
Task.Delay(500).ContinueWith(delegate
{
BluetoothService.Instance.Connect(GetRegisteredDevice(), GetRegisteredDeviceModel());
});
return;
}
GenerateTrayContext(-1, -1, -1);
BluetoothService.Instance.Disconnect();
_mainPage.SetWarning(true, $"{Loc.GetString("mainpage_corrupt_data")} ({e.Message})");
Task.Delay(500).ContinueWith(delegate
{
BluetoothService.Instance.Connect(GetRegisteredDevice(), GetRegisteredDeviceModel());
_mainPage.SetWarning(false);
});
});
}
protected override Exception OnSizeQuotaExceeded(int size)
{
Exception result = new InvalidDataException(string.Format(SRServiceModel.FramingContentTypeTooLong, size));
FramingEncodingString.AddFaultString(result, FramingEncodingString.ContentTypeTooLongFault);
return(result);
}
protected override void ProcessRecord()
{
const string particular = @"Software\ParticularSoftware";
ProviderInfo provider;
PSDriveInfo drive;
var psPath = SessionState.Path.GetUnresolvedProviderPathFromPSPath(LicenseFile, out provider, out drive);
if (provider.ImplementingType != typeof(FileSystemProvider))
{
var ex = new ArgumentException(string.Format("{0} does not resolve to a path on the FileSystem provider.", psPath));
var error = new ErrorRecord(ex, "InvalidProvider", ErrorCategory.InvalidArgument, psPath);
WriteError(error);
return;
}
var content = File.ReadAllText(psPath);
if (!CheckFileContentIsALicenseFile(content))
{
var ex = new InvalidDataException(string.Format("{0} is not not a valid license file", psPath));
var error = new ErrorRecord(ex, "InvalidLicense", ErrorCategory.InvalidData, psPath);
WriteError(error);
return;
}
if (EnvironmentHelper.Is64BitOperatingSystem)
{
RegistryHelper.LocalMachine(RegistryView.Registry64).WriteValue(particular, "License", content, RegistryValueKind.String);
}
RegistryHelper.LocalMachine(RegistryView.Registry32).WriteValue(particular, "License", content, RegistryValueKind.String);
}
public void InvalidDataExceptionTest()
{
var exception = new InvalidDataException("error");
var result = ExceptionTest(exception);
Assert.AreEqual(exception, result.InnerException);
}
protected override Exception OnSizeQuotaExceeded(int size)
{
Exception exception = new InvalidDataException(System.ServiceModel.SR.GetString("FramingContentTypeTooLong", new object[] { size }));
FramingEncodingString.AddFaultString(exception, "http://schemas.microsoft.com/ws/2006/05/framing/faults/ContentTypeTooLong");
return(exception);
}
/// <inheritdoc />
/// <remarks>File must contain "Status" and "Thing Name" columns.</remarks>
/// <exception cref="InvalidDataException">CSV file doesn't contain header.</exception>
public List <string> ReadCsvFile(string filename)
{
// Use HashSet to avoid duplicated data which can produce errors in further work.
var result = new HashSet <string>();
using (var reader = new StreamReader(filename))
{
var csv = new CsvReader(
reader, new CsvHelper.Configuration.Configuration {
HasHeaderRecord = true
}
);
if (!csv.Read() || !csv.ReadHeader())
{
var ex = new InvalidDataException("CSV file doesn't contain header!");
_logger.Error(ex, "Got CSV file without header.");
throw ex;
}
while (csv.Read())
{
string status = csv[_statusHeader];
if (!string.IsNullOrEmpty(status))
{
continue;
}
string field = csv[_thingNameHeader];
result.Add(field);
}
}
return(result.ToList());
}
public static async Task <bool> WriteFrameAsync(ArraySegment <byte> frame, Stream stream, string traceType)
{
bool complete;
var marker = BitConverter.ToInt32(frame.Array, frame.Offset);
if (marker == BeginFrameMarker)
{
complete = false;
}
else if (marker == EndFramesMarker)
{
complete = true;
}
else
{
var exc = new InvalidDataException(string.Format("CheckpointFileHelper.WriteFrameAsync : marker = {0}", marker));
FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
throw exc;
}
await stream.WriteAsync(frame.Array, frame.Offset, frame.Count).ConfigureAwait(false);
return(complete);
}
public void WhenDisposalOfAnItemFails_StillDisposesOthers_ThrowsAggregateException()
{
var firstDisposable = A.Fake <IDisposable>();
var secondDisposable = A.Fake <IDisposable>();
var thirdDisposable = A.Fake <IDisposable>();
_sut.Add("D1", firstDisposable, true);
_sut.Add("D2", secondDisposable, true);
_sut.Add("D3", thirdDisposable, true);
var failureReason1 = new InvalidOperationException("I am the cause of the failure of the first disposable");
A.CallTo(() => firstDisposable.Dispose()).Throws(failureReason1);
var failureReason2 = new InvalidDataException("I am the cause of the failure of the second disposable");
A.CallTo(() => secondDisposable.Dispose()).Throws(failureReason2);
Action act = () => _sut.Dispose();
act.Should().Throw <AggregateException>()
.Where(_ => _.InnerExceptions.SequenceEqual(new Exception[] { failureReason1, failureReason2 }));
A.CallTo(() => firstDisposable.Dispose()).MustHaveHappened();
A.CallTo(() => secondDisposable.Dispose()).MustHaveHappened();
A.CallTo(() => thirdDisposable.Dispose()).MustHaveHappened();
}
public async Task <AppUserDto> AddUserToChat(int chatId, string userId)
{
var defaultError = new InvalidDataException("Invalid credentials were provided.");
var FoundConversation = await conversationRepository.GetByIdAsync(chatId);
if (FoundConversation == null)
{
throw defaultError;
}
var FoundUser = await usersRepository.GetByIdAsync(userId);
if (FoundUser == null)
{
throw defaultError;
}
if (await usersConversationsRepository.Exists(FoundUser.Id, FoundConversation.Id))
{
throw new InvalidDataException("User already exists in converation.");
}
var addedUser = (await usersConversationsRepository.AddAsync(UsersConversationDataModel.Create(userId, chatId))).User;
await rolesRepository.AddAsync(ChatRoleDataModel.Create(chatId, userId, ChatRole.NoRole));
await unitOfWork.Commit();
return(addedUser.ToAppUserDto());
}
public void TestDown()
{
InvalidDataException repoDBException = null;
try {
this.repo.RunDbObjectValidationCheck();
} catch (InvalidDataException e) {
repoDBException = e;
}
this.repo.Dispose();
if (this.localRootDir.Exists)
{
this.localRootDir.Delete(true);
}
this.remoteRootDir.Refresh();
this.remoteRootDir.DeleteTree(true, null, true);
this.repo.Dispose();
if (repoDBException != null)
{
throw new Exception(repoDBException.Message, repoDBException);
}
}
protected Exception CreateException(InvalidDataException innerException, string framingFault)
{
Exception exception = this.CreateException(innerException);
FramingEncodingString.AddFaultString(exception, framingFault);
return(exception);
}
public void LoadJsonManifestFrom_ReturnsNullIfStreamIsEmpty()
{
var mockLogger = new Mock <Logger>();
Log.Default = mockLogger.Object;
var mockException = new InvalidDataException("Manifest is empty or failed to load and is null.");
Assert.IsNull(
ManifestLoader.LoadJsonManifestFrom(
new MockAssembly
{
MockManifestResourceInfo = new Dictionary <string, ManifestResourceInfo>
{
{
@"manifest.json",
typeof(ManifestLoaderTest).Assembly.GetManifestResourceInfo(
$@"{VirtualTestManifest.Namespace}.manifest.lowercase.json"
)
}
},
MockManifestResourceStream = new Dictionary <string, Stream>
{
{ @"manifest.json", new MemoryStream() }
}
}
)
);
mockLogger.Verify(
l => l.Warn(
It.Is <InvalidDataException>(e => e.Message == mockException.Message),
"Failed to load manifest.json from MockAssembly."
)
);
}
protected Exception CreateException(InvalidDataException innerException, string framingFault)
{
Exception result = CreateException(innerException);
FramingEncodingString.AddFaultString(result, framingFault);
return(result);
}
public void ParseWindowsLiveResponseNoFragment()
{
string invalidUrlFragment = "https://login.live.com/oauth20_desktop.srf?lc=1337";
InvalidDataException ex = Assert.Throws <InvalidDataException>(
delegate { AuthenticationService.ParseWindowsLiveResponse(invalidUrlFragment); });
Assert.IsTrue(ex.Message.StartsWith("Invalid URL fragment"));
}
public static void MessageInnerExceptionConstructor()
{
string message = "MessageConstructor";
Exception innerException = new Exception();
InvalidDataException ide = new InvalidDataException(message, innerException);
Assert.Equal(message, ide.Message);
Assert.Same(innerException, ide.InnerException);
}
public void ThrowsIfBadJson(string path)
{
InvalidDataException exception = Assert.Throws <InvalidDataException>(() =>
{
SslConfigLoader.LoadCertJson(Path.Combine(TestDir, path));
});
Assert.That(exception.Message, Does.StartWith("Cert Json didnt not contain \"path\""));
}
public static void MessageInnerExceptionConstructor()
{
string message = "MessageConstructor";
Exception innerException = new Exception();
InvalidDataException ide = new InvalidDataException(message, innerException);
Assert.Equal(message, ide.Message);
Assert.Same(innerException, ide.InnerException);
}
/// <summary>
/// Creates FFmpegException from XmlDocument
/// </summary>
/// <param name="xmlDoc">XmlDocument containing data for creating FFmpegException object.</param>
/// <returns>FFmpegException object</returns>
public static FFmpegException CreateFromXml(XmlDocument xmlDoc) {
FFmpegException exception = null;
if (xmlDoc.DocumentElement != null) {
XmlNode formatNode = xmlDoc.DocumentElement.SelectSingleNode(FORMAT_NODE);
if (formatNode != null && formatNode.Attributes != null) {
var code = formatNode.Attributes[CODE] != null
? Int32.Parse(formatNode.Attributes[CODE].InnerText)
: 0;
var message = formatNode.Attributes[MESSAGE] != null ? formatNode.Attributes[MESSAGE].InnerText : null;
switch (code) {
case -1:
exception = new OperationNotPermittedException();
break;
case -5:
exception = new IOException();
break;
case -10060:
exception = new UnknownException();
break;
case -1094995529:
exception = new InvalidDataException();
break;
default:
exception = new FFmpegException(message, code);
break;
}
}
}
return exception;
}
public static void DefaultConstructor()
{
InvalidDataException ide = new InvalidDataException();
Assert.NotNull(ide.Message);
}
