public string ActionExecuteExceptionLog(ChangesHeader _ChangesHeader, List <ChangeItem> _ChangeItemCollection, ThrowingException _ThrowingException)
{
string _Result = string.Empty;
MappingException _MappingException = null;
string _XML = string.Empty;
List <DbParameter> _ParameterList = new List <DbParameter>();
string _ConnectionString = ConfigurationManager.ConnectionStrings["BrErpSindicatoV04_HistoricoModificacoes"].ConnectionString;
string _ProviderName = ConfigurationManager.ConnectionStrings["BrErpSindicatoV04_HistoricoModificacoes"].ProviderName;
string _TSQL = "[dbo].[Log_ModificaLogExcecoes]";
_MappingException = ServiceHelper.CreateInstance.GetMappingExceptions(_ChangesHeader, _ChangeItemCollection, _ThrowingException);
_XML = SerializationData.CreateInstance.GetSerializableData(_MappingException, "MappingExecuteExceptionLog");
_ParameterList.Add(DatabasePersistence.CreateInstance(_ConnectionString, _ProviderName).CreateParameter("@XMLExceptionLog", System.Data.DbType.Xml, _XML));
try
{
_Result = Convert.ToString(DatabasePersistence.CreateInstance(_ConnectionString, _ProviderName).ExecuteCommand(_TSQL, CommandType.StoredProcedure, _ParameterList, ExecuteType.ExecuteScalar));
}
catch (Exception ex)
{
ExceptionHandling.CreateInstance.AddExceptionAndSaveTextFile(ex);
}
return(_Result);
}
private static byte[] SerializeToBytes(MappingException e)
{
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, e);
return(stream.GetBuffer());
}
}
public void MappingExceptionSerialization()
{
var message = "Test message";
var exception = new MappingException(message);
var actual = SerializeToBytes(exception);
actual.Length.Should().BeGreaterThan(0);
}
public void MappingExceptionWithMessage()
{
var message = "Test message";
FluentActions.Invoking(() => systemUnderTest = new MappingException(message))
.Should()
.NotThrow();
Assert.AreEqual(message, systemUnderTest.Message);
}
public MappingException GetMappingExceptions(ChangesHeader _ChangeHeader, List <ChangeItem> _ChangeItems, ThrowingException _ThrowingException)
{
MappingException _MappingException = null;
List <ChangesHeader> _ChangeHeadersHelper = new List <ChangesHeader>();
List <ChangeItem> _ChangeItemsHelper = new List <ChangeItem>();
List <ThrowingException> ThrowingExceptionsHelper = new List <ThrowingException>();
_ChangeHeadersHelper.Add(new ChangesHeader()
{
Id = _ChangeHeader.Id,
CodigoRegistro = _ChangeHeader.CodigoRegistro,
NomeProcesso = _ChangeHeader.NomeProcesso,
TipoModificacao = _ChangeHeader.TipoModificacao,
Usuario = _ChangeHeader.Usuario,
DataHora = _ChangeHeader.DataHora,
StatusExecucao = _ChangeHeader.StatusExecucao
});
foreach (ChangeItem _ChangeItem in _ChangeItems)
{
_ChangeItemsHelper.Add(new ChangeItem()
{
IdChangeHeader = _ChangeItem.IdChangeHeader,
IdItem = _ChangeItem.IdItem,
NomeTabela = _ChangeItem.NomeTabela,
NomeCampo = _ChangeItem.NomeCampo,
ValorAntigo = _ChangeItem.ValorAntigo,
ValorNovo = _ChangeItem.ValorNovo
});
}
ThrowingExceptionsHelper.Add(new ThrowingException()
{
Id = _ThrowingException.Id,
IdChangeHeader = _ThrowingException.IdChangeHeader,
Formulario = _ThrowingException.Formulario,
Tarefa = _ThrowingException.Tarefa,
FuncaoDisparador = _ThrowingException.FuncaoDisparador,
TipoExcecao = _ThrowingException.TipoExcecao,
MensagemExcecao = _ThrowingException.MensagemExcecao
});
if (_MappingException == null)
{
_MappingException = new MappingException();
}
_MappingException.ChangeHeaders = _ChangeHeadersHelper;
_MappingException.ChangeItems = _ChangeItemsHelper;
_MappingException.ThrowingExceptions = ThrowingExceptionsHelper;
return(_MappingException);
}
public void serialization_works_with_datacontract()
{
var serializer = new DataContractSerializer(typeof(MappingException));
var ms = new MemoryStream();
var sut = new MappingException(typeof(string), "Hello");
serializer.WriteObject(ms, sut);
ms.Position = 0;
var actual = (MappingException)serializer.ReadObject(ms);
actual.Message.Should().Be("Hello");
actual.EntityTypeName.Should().Be(typeof(string).FullName);
}
public void MappingExceptionDeserialization()
{
var message = "Test message";
var exception = new MappingException(message);
var bytes = SerializeToBytes(exception);
bytes.Length.Should().BeGreaterThan(0);
var actual = DeserializeFromBytes(bytes);
actual.Message.Should().Be(message);
actual.InnerException.Should().BeNull();
}
public void CannotOverloadHandleMethods()
{
var serviceProvider = new Mock <IServiceProvider>();
var attribute = new HandleByAttributeAttribute {
PublicOnly = false
};
var expectedException = new MappingException(Exceptions.HandleMethodOverloaded.FormatWith(typeof(FakeAggregate), "Void Handle(FakeCommand, FakeService, FakeService)"));
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(null);
var actualException = Assert.Throws <MappingException>(() => attribute.GetHandleMethods(typeof(FakeAggregate), serviceProvider.Object));
Assert.Equal(expectedException.Message, actualException.Message);
}
public void serialization_works_with_BinaryFormatter()
{
var serializer = new BinaryFormatter();
var ms = new MemoryStream();
var sut = new MappingException(typeof(string), "Hello");
serializer.Serialize(ms, sut);
ms.Position = 0;
var actual = (MappingException)serializer.Deserialize(ms);
actual.Message.Should().Be("Hello");
actual.EntityTypeName.Should().Be(typeof(string).FullName);
}
private static Expression WrapInTryCatch(Expression mappingBlock, IMemberMapperData mapperData)
{
var configuredCallback = mapperData.MapperContext.UserConfigurations.GetExceptionCallbackOrNull(mapperData);
var exceptionVariable = Parameters.Create <Exception>("ex");
Expression catchBody;
if (configuredCallback != null)
{
var callbackActionType = configuredCallback.Type.GetGenericTypeArguments()[0];
Type[] contextTypes;
Expression contextAccess;
if (callbackActionType.IsGenericType())
{
contextTypes = callbackActionType.GetGenericTypeArguments();
contextAccess = mapperData.GetAppropriateTypedMappingContextAccess(contextTypes);
}
else
{
contextTypes = new[] { mapperData.SourceType, mapperData.TargetType };
contextAccess = mapperData.MappingDataObject;
}
var exceptionContextCreateMethod = ObjectMappingExceptionData
.CreateMethod
.MakeGenericMethod(contextTypes);
var exceptionContextCreateCall = Expression.Call(
exceptionContextCreateMethod,
contextAccess,
exceptionVariable);
var callbackInvocation = Expression.Invoke(configuredCallback, exceptionContextCreateCall);
var returnDefault = mappingBlock.Type.ToDefaultExpression();
catchBody = Expression.Block(callbackInvocation, returnDefault);
}
else
{
catchBody = Expression.Throw(
MappingException.GetFactoryMethodCall(mapperData, exceptionVariable),
mappingBlock.Type);
}
var catchBlock = Expression.Catch(exceptionVariable, catchBody);
return(Expression.TryCatch(mappingBlock, catchBlock));
}
public void AddClassNotFound()
{
Configuration cfg = new Configuration();
try
{
cfg.AddResource("NHibernate.Test.MappingExceptions.A.ClassNotFound.hbm.xml", this.GetType().Assembly);
}
catch (MappingException me)
{
Assert.IsTrue(me.InnerException is MappingException);
MappingException innerMe = (MappingException)me.InnerException;
Assert.AreEqual("persistent class " + typeof(A).FullName + " not found", innerMe.Message);
}
}
public void Bug()
{
try
{
new Configuration()
.AddResource(GetType().Namespace + ".EmptyTableName.hbm.xml", GetType().Assembly)
.BuildSessionFactory();
Assert.Fail("should throw exception");
}
catch (MappingException e)
{
MappingException ee = e.InnerException as MappingException;
if (ee == null)
{
throw;
}
Assert.IsTrue(ee.Message.StartsWith("Could not determine the name of the table for entity"));
}
}
public static TryExpression WrapInTryCatch(this Expression mapping, IMemberMapperData mapperData)
{
var configuredCallback = mapperData.MapperContext.UserConfigurations.GetExceptionCallbackOrNull(mapperData);
var exceptionVariable = Parameters.Create <Exception>("ex");
if (configuredCallback == null)
{
var catchBody = Expression.Throw(
MappingException.GetFactoryMethodCall(mapperData, exceptionVariable),
mapping.Type);
return(CreateTryCatch(mapping, exceptionVariable, catchBody));
}
var configuredCatchBody = configuredCallback
.ToCatchBody(exceptionVariable, mapping.Type, mapperData);
return(CreateTryCatch(mapping, exceptionVariable, configuredCatchBody));
}
private void LogFailedToMapProperty(PropertyInfo property, MappingException exception)
{
Log.LogError(exception, "Failed to map {0} property.", property.Name);
}
public void Setup()
{
systemUnderTest = new MappingException();
}
public void type_is_assigned_to_the_property()
{
var sut = new MappingException(typeof(string), "Hello");
sut.EntityTypeName.Should().Be(typeof(string).FullName);
}
public void MappingExceptionDefaultConstructor()
{
FluentActions.Invoking(() => systemUnderTest = new MappingException())
.Should()
.NotThrow();
}
public void CannotOverloadHandleMethods()
{
var serviceProvider = new Mock<IServiceProvider>();
var attribute = new HandleByConventionAttribute { PublicOnly = false };
var expectedException = new MappingException(Exceptions.HandleMethodOverloaded.FormatWith(typeof(FakeHandler), "Void Handle(FakeEvent, FakeService, FakeService)"));
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(null);
var actualException = Assert.Throws<MappingException>(() => attribute.GetHandleMethods(typeof(FakeHandler), serviceProvider.Object));
Assert.Equal(expectedException.Message, actualException.Message);
}
public void description_is_assigned_to_base()
{
var sut = new MappingException(typeof(string), "Hello");
sut.Message.Should().Be("Hello");
}
private static void LogAndThrow(MappingException me)
{
log.Error(me.Message, me);
throw me;
}
