public static void Executar()
{
var validacaoCadastro = new Mensagem("O cadastro não foi realizado!");
var usuarioFormErro = new Mensagem("O usuário informou um nome inválido!");
var tamanhoNomeForm = new InputFormMessage("O nome precisa possuir mais de 2 caracteres!");
var nomeVazioForm = new InputFormMessage("O nome não pode possuir numeros!");
usuarioFormErro.AdicionarMensagem(tamanhoNomeForm);
usuarioFormErro.AdicionarMensagem(nomeVazioForm);
validacaoCadastro.AdicionarMensagem(usuarioFormErro);
var domainUsuarioErro = new Mensagem("Problems ao processar o cadastro de usuario!");
var cpfUsuarioDomain = new DomainMessage("O CPF informado está em uso!");
var emailUsuarioDomain = new DomainMessage("O Email informado está em uso!");
domainUsuarioErro.AdicionarMensagem(cpfUsuarioDomain);
domainUsuarioErro.AdicionarMensagem(emailUsuarioDomain);
validacaoCadastro.AdicionarMensagem(domainUsuarioErro);
validacaoCadastro.ExibirMensagens(2);
}
public static void Run()
{
var validacaoCadastro = new Mensagem("O cadastro não foi realizado!");
var usuarioFormErro = new Mensagem("O usuário informou um nome inválido");
var tamanhoNomeForm = new InputFormMessage("O nome precisa possuir mais de 2 caracteres");
var nomeVazioForm = new InputFormMessage("Campo obrigatório.");
usuarioFormErro.AdicionarFilha(tamanhoNomeForm);
usuarioFormErro.AdicionarFilha(nomeVazioForm);
validacaoCadastro.AdicionarFilha(usuarioFormErro);
var domainUsuarioErro = new Mensagem("Problemas ao processar o cadastro de usuario");
var cpfUsuarioDomain = new DomainMessage("O CPF informado está em uso!");
var emailUsuarioDomain = new DomainMessage("O Email informado está em uso!");
domainUsuarioErro.AdicionarFilha(cpfUsuarioDomain);
domainUsuarioErro.AdicionarFilha(emailUsuarioDomain);
validacaoCadastro.AdicionarFilha(domainUsuarioErro);
var msgNivel_1 = new Mensagem("Nível 1");
var msgNivel_2 = new Mensagem("Nível 2");
var msgNivel_3 = new Mensagem("Nível 3");
var msgNivel_4 = new Mensagem("Nível 4");
var msgNivel_5 = new Mensagem("Nível 5");
msgNivel_4.AdicionarFilha(msgNivel_5);
msgNivel_3.AdicionarFilha(msgNivel_4);
msgNivel_2.AdicionarFilha(msgNivel_3);
msgNivel_1.AdicionarFilha(msgNivel_2);
validacaoCadastro.AdicionarFilha(msgNivel_1);
validacaoCadastro.ExibirMensagens(2);
}
private void Handle(DomainMessage message)
{
var srv = message.Answers.FirstOrDefault(a => a.Type == RRType.SRV &&
a.Class == Class.IN &&
a.Name.EndsWith($"{_serviceType}.{_domain}."));
if (srv == null)
{
return;
}
_logger.Debug($"Got\n{message}");
var record = (SRVRecord)srv.Record;
var service = new NetworkService
{
Name = srv.Name.Split('.')[0],
Type = _serviceType,
Domain = _domain,
Port = record.Port,
HostName = record.Target
};
_logger.Info($"AddOrUpdate {service.Name}, ttl: {srv.Ttl}");
_services.AddOrUpdate(service.Name, service, (int)srv.Ttl);
}
public MessageEndpointContext AddUnprocessed(DomainMessage e)
{
return(new MessageEndpointContext(
ProcessedSuccessfully,
ProcessedUnsuccessfully,
Unprocessed.Concat(new[] { e }),
this.SourceQueue));
}
private void WriteHeader(DomainMessage message)
{
var header = CreateHeader(message);
_bytes.AddRange(header.Id.ToBytes());
_bytes.AddRange(header.Flags.ToBytes());
_bytes.AddRange(header.QDCount.ToBytes());
_bytes.AddRange(header.ANCount.ToBytes());
_bytes.AddRange(header.NSCount.ToBytes());
_bytes.AddRange(header.ARCount.ToBytes());
}
/// <summary>
/// Checks if the Guid is not empty
/// </summary>
/// <param name="param">Data that will be validated.</param>
public static ArgumentValidationResult IdNotEmpty(this Param <Guid> param)
{
if (param._value == Guid.Empty)
{
var domainError = DomainError.New(param._name, DomainMessage.IdNotExist(param._name));
return(ArgumentValidationResult.New(domainError));
}
return(ArgumentValidationResult.Success);
}
/// <summary>
/// Checks is the entity is not null.
/// </summary>
/// <typeparam name="T">argument's type.</typeparam>
/// <param name="param">Data that will be validated.</param>
public static void EntityExists <T>(this Param <T> param)
{
if (param._value == null)
{
if (param._customException != null)
{
param._customException.Invoke();
}
throw new Exception(DomainMessage.IdNotExist(param._name));
}
}
/// <summary>
/// Checks if arg is not null.
/// </summary>
/// <param name="param">Data that will be validated.</param>
public static void IsNullOrWhiteSpace(this Param <string> param)
{
if (string.IsNullOrWhiteSpace(param._value))
{
if (param._customException != null)
{
param._customException.Invoke();
}
throw new ArgumentException(DomainMessage.IsNullOrWhiteSpace(nameof(param._name)));
}
}
/// <summary>
/// Checks if entity is not null.
/// </summary>
/// <typeparam name="T">argument's type.</typeparam>
/// <param name="param">Data that will be validated.</param>
public static void EntityIsNotNull <T>(this Param <T> param)
{
if (param._value == null)
{
if (param._customException != null)
{
param._customException.Invoke();
}
throw new DomainException(param._name, DomainMessage.EntityIsNull(param._name));
}
}
/// <summary>
/// Checks if the int is greather than zero
/// </summary>
/// <param name="param">Data that will be validated.</param>
public static void HasValue(this Param <int> param)
{
if (param._value == 0)
{
if (param._customException != null)
{
param._customException.Invoke();
}
throw new Exception(DomainMessage.IdNotExist(param._name));
}
}
/// <summary>
/// Return all customers
/// </summary>
public RopResult <IEnumerable <Customer>, DomainMessage> GetAll()
{
var db = new DbContext();
var ropResults = db.Customers().Select(FromDbCustomer);
if (ropResults.Any(r => !r.IsSuccess))
{
return(Rop.Fail <IEnumerable <Customer>, DomainMessage>(DomainMessage.SqlCustomerIsInvalid()));
}
else
{
var goodResults = ropResults.Select(r => r.SuccessValue);
return(Rop.Succeed <IEnumerable <Customer>, DomainMessage>(goodResults));
}
}
/// <summary>
/// Return the customer with the given CustomerId, or null if not found
/// </summary>
public RopResult <Customer, DomainMessage> GetById(CustomerId id)
{
var db = new DbContext();
// Note that this code does not trap exceptions coming from the database. What would it do with them?
// Compare with the F# version, where errors are returned along with the Customer
var result = db.Customers().Where(c => c.Id == id.Value).Select(FromDbCustomer).FirstOrDefault();
if (result == null)
{
return(Rop.Fail <Customer, DomainMessage>(DomainMessage.CustomerNotFound()));
}
return(result);
}
public byte[] Write(DomainMessage message)
{
WriteHeader(message);
foreach (var question in message.Questions)
{
Write(question);
}
foreach (var answer in message.Answers)
{
Write(answer);
}
return(_bytes.ToArray());
}
public static DomainMessage AddEvent(SomethingHappenedEvent e)
{
var lastEvent = Events.Last();
var newEvent = new DomainMessage(
new MessageHeader(
lastEvent.Header.MessageNumber + 1,
DateTimeOffset.UtcNow,
SomethingHappenedEvent.DomainMessageType,
null,
null
),
e
);
Events.Add(newEvent);
return(newEvent);
}
/// <summary>
/// Convert a DbCustomer into a domain Customer
/// </summary>
public static RopResult <Customer, DomainMessage> FromDbCustomer(DbCustomer sqlCustomer)
{
if (sqlCustomer == null)
{
return(Rop.Fail <Customer, DomainMessage>(DomainMessage.CustomerNotFound()));
}
var firstName = DomainUtilities.CreateFirstName(sqlCustomer.FirstName);
var lastName = DomainUtilities.CreateLastName(sqlCustomer.LastName);
var createName = Rop.Lift2 <String10, String10, PersonalName, DomainMessage>(PersonalName.Create);
var name = createName(firstName, lastName);
var id = DomainUtilities.CreateCustomerId(sqlCustomer.Id);
var email = DomainUtilities.CreateEmail(sqlCustomer.Email);
var createCust = Rop.Lift3 <CustomerId, PersonalName, EmailAddress, Customer, DomainMessage>(Customer.Create);
var cust = createCust(id, name, email);
return(cust);
}
private static Header CreateHeader(DomainMessage message)
{
return(new Header
{
Id = message.Id,
QR = message.Type != MessageType.Query,
OPCODE = message.OpCode,
AA = message.AuthoriativeAnswer,
TC = message.Truncation,
RD = message.RecursionDesired,
RA = message.RecursionAvailable,
Z = 0,
RCODE = message.ResponseCode,
QDCount = (ushort)message.Questions.Count,
ANCount = (ushort)message.Answers.Count,
NSCount = (ushort)message.Authorities.Count,
ARCount = (ushort)message.Additionals.Count
});
}
private static MessageEndpointContext ProcessNext(
MessageEndpointContext endpointContext,
DomainMessage domainMessage,
Func <Type, Action <DomainMessageProcessingContext, object> > processors)
{
if (endpointContext.ProcessedUnsuccessfully.Any())
{
return(endpointContext.AddUnprocessed(domainMessage));
}
var processingResult = DomainMessageProcessor.ProcessMessage(
domainMessage,
endpointContext.SourceQueue,
processors);
return(processingResult.GetType() == typeof(DomainMessageProcessor.ProcessMessageSuccess)
? endpointContext.AddSuccess(domainMessage)
: endpointContext.AddFailure(domainMessage));
}
/// <summary>
/// Create a domain customer from a DTO or null if not valid.
/// </summary>
public static RopResult <Customer, DomainMessage> DtoToCustomer(CustomerDto dto)
{
if (dto == null)
{
// dto can be null if deserialization fails
return(Rop.Fail <Customer, DomainMessage>(DomainMessage.CustomerIsRequired()));
}
var firstName = DomainUtilities.CreateFirstName(dto.FirstName);
var lastName = DomainUtilities.CreateLastName(dto.LastName);
var createName = Rop.Lift2 <String10, String10, PersonalName, DomainMessage>(PersonalName.Create);
var name = createName(firstName, lastName);
var id = DomainUtilities.CreateCustomerId(dto.Id);
var email = DomainUtilities.CreateEmail(dto.Email);
var createCust = Rop.Lift3 <CustomerId, PersonalName, EmailAddress, Customer, DomainMessage>(Customer.Create);
var cust = createCust(id, name, email);
return(cust);
}
public static IProcessMessageResult ProcessMessage(
DomainMessage message,
MessageEndpointName queueName,
Func <Type, Action <DomainMessageProcessingContext, object> > processors)
{
Logger.Trace($"ProcessMessage: {message.Header}");
var context = new DomainMessageProcessingContext(
new Retries(HandlerRetryCount),
message.Header,
queueName
);
Either <DeserializeError, object> msg2 =
new Either <DeserializeError, object>(message.Message);
return(msg2.Match(
e => new DeserializationError(e.Exception),
msg3 => ProcessMsg(msg3, context, processors)));
}
public string Index()
{
Eventos.LimparDados();
var validacaoCadastro = new Mensagem("O cadastro não foi realizado!");
var usuarioFormErro = new Mensagem("O usuário informou um nome inválido");
var tamanhoNomeForm = new InputFormMessage("O nome precisa possuir mais de 2 caracteres");
var nomeVazioForm = new InputFormMessage("O nome não pode possuir numeros");
usuarioFormErro.AdicionarFilha(tamanhoNomeForm);
usuarioFormErro.AdicionarFilha(nomeVazioForm);
validacaoCadastro.AdicionarFilha(usuarioFormErro);
var domainUsuarioErro = new Mensagem("Problemas ao processar o cadastro de usuario");
var cpfUsuarioDomain = new DomainMessage("O CPF informado está em uso!");
var emailUsuarioDomain = new DomainMessage("O Email informado está em uso!");
domainUsuarioErro.AdicionarFilha(cpfUsuarioDomain);
domainUsuarioErro.AdicionarFilha(emailUsuarioDomain);
validacaoCadastro.AdicionarFilha(domainUsuarioErro);
var msgNivel1 = new Mensagem("Nivel 1");
var msgNivel2 = new Mensagem("Nivel 2");
var msgNivel3 = new Mensagem("Nivel 3");
var msgNivel4 = new Mensagem("Nivel 4");
var msgNivel5 = new Mensagem("Nivel 5");
msgNivel4.AdicionarFilha(msgNivel5);
msgNivel3.AdicionarFilha(msgNivel4);
msgNivel2.AdicionarFilha(msgNivel3);
msgNivel1.AdicionarFilha(msgNivel2);
validacaoCadastro.AdicionarFilha(msgNivel1);
validacaoCadastro.ExibirMensagens(2);
return(Eventos.Imprimir());
}
public static void Executar()
{
var validacaoCadastro = new Mensagem("O cadastro não foi realizado!");
var usuarioFormErro = new Mensagem("O usuário informou um nome inválido");
var tamanhoNomeForm = new InputFormMessage("O nome precisa possuir mais de 2 caracteres");
var nomeEmBrancoOuVazioForm = new InputFormMessage("O nome não pode estar em branco ou possuir números");
usuarioFormErro.AdicionarFilha(tamanhoNomeForm);
usuarioFormErro.AdicionarFilha(nomeEmBrancoOuVazioForm);
validacaoCadastro.AdicionarFilha(usuarioFormErro);
var domainUsuarioErro = new Mensagem("Problemas ao processar o cadastro do usuário");
var cpfUsuarioDomain = new DomainMessage("O CPF informado está em uso por outra pessoa!");
var emailUsuarioDomain = new DomainMessage("O e-mail informado está em uso por outro usuário!");
domainUsuarioErro.AdicionarFilha(cpfUsuarioDomain);
domainUsuarioErro.AdicionarFilha(emailUsuarioDomain);
validacaoCadastro.AdicionarFilha(domainUsuarioErro);
var msgNivel1 = new Mensagem("Nível 1");
var msgNivel2 = new Mensagem("Nível 2");
var msgNivel3 = new Mensagem("Nível 3");
var msgNivel4 = new Mensagem("Nível 4");
var msgNivel5 = new Mensagem("Nível 5");
msgNivel4.AdicionarFilha(msgNivel5);
msgNivel3.AdicionarFilha(msgNivel4);
msgNivel2.AdicionarFilha(msgNivel3);
msgNivel1.AdicionarFilha(msgNivel2);
validacaoCadastro.AdicionarFilha(msgNivel1);
validacaoCadastro.ExibirMensagens(nivelMensagem: 2);
}
public static void Execute()
{
var registrationValidation = new Message("The registration was not carried out!");
var userFormError = new Message("The user entered an invalid name");
var formNameSize = new InputFormMessage("The name must be longer than 2 characters");
var emptyNameForm = new InputFormMessage("The name cannot have numbers");
userFormError.AddChild(formNameSize);
userFormError.AddChild(emptyNameForm);
registrationValidation.AddChild(userFormError);
var domainUserError = new Message("Problems processing the user registration");
var cpfUserDomain = new DomainMessage("The informed CPF is in use!");
var emailUserDomain = new DomainMessage("The informed email is in use!");
domainUserError.AddChild(cpfUserDomain);
domainUserError.AddChild(emailUserDomain);
registrationValidation.AddChild(domainUserError);
var level1Message = new Message("Level 1");
var level2Message = new Message("Level 2");
var level3Message = new Message("Level 3");
var level4Message = new Message("Level 4");
var level5Message = new Message("Level 5");
level4Message.AddChild(level5Message);
level3Message.AddChild(level4Message);
level2Message.AddChild(level3Message);
level1Message.AddChild(level2Message);
registrationValidation.AddChild(level1Message);
registrationValidation.DisplayMessages(2);
}
/// <summary>
/// Insert/update the customer
/// If it already exists, update it, otherwise insert it.
/// If the email address has changed, raise a EmailAddressChanged event on DomainEvents
/// </summary>
public RopResult <Unit, DomainMessage> Upsert(Customer customer)
{
if (customer == null)
{
throw new ArgumentNullException("customer");
}
var db = new DbContext();
var existingDbCust = GetById(customer.Id);
var newDbCust = ToDbCustomer(customer);
return(Rop.Match(existingDbCust,
success =>
{
// update
db.Update(newDbCust);
// check for changed email
if (!customer.EmailAddress.Equals(success.EmailAddress))
{
// return a Success with the extra event
var msg = DomainMessage.EmailAddressChanged(success.EmailAddress, customer.EmailAddress);
return Rop.SucceedWithMsg <Unit, DomainMessage>(Unit.Instance, msg);
}
else
{
// return a Success with no extra event
return Rop.Succeed <Unit, DomainMessage>(Unit.Instance);
}
},
failure =>
{
// insert
db.Insert(newDbCust);
// return a Success
return Rop.Succeed <Unit, DomainMessage>(Unit.Instance);
}));
}
private DomainMessage ReadMessage(Header header)
{
var message = new DomainMessage
{
Id = header.Id,
Type = header.QR ? MessageType.Response : MessageType.Query,
OpCode = header.OPCODE,
AuthoriativeAnswer = header.AA,
Truncation = header.TC,
RecursionDesired = header.RD,
RecursionAvailable = header.RA,
ResponseCode = header.RCODE
};
for (var ii = 0; ii < header.QDCount; ii++)
{
message.Questions.Add(ReadQuestion());
}
for (var ii = 0; ii < header.ANCount; ii++)
{
message.Answers.Add(ReadResourceRecord());
}
for (var ii = 0; ii < header.NSCount; ii++)
{
message.Authorities.Add(ReadResourceRecord());
}
for (var ii = 0; ii < header.ARCount; ii++)
{
message.Additionals.Add(ReadResourceRecord());
}
return(message);
}
public static byte[] Encode(DomainMessage message)
{
return(new MessageWriter().Write(message));
}
