public async Task <MailServerConfiguration> UpdateAdminMailServerAsync(MailServerConfiguration mailServerConfiguration)
{
var response = await GetAdminUrl("/mail-server")
.PutJsonAsync(mailServerConfiguration)
.ConfigureAwait(false);
return(await HandleResponseAsync <MailServerConfiguration>(response).ConfigureAwait(false));
}
public static Configuration AddMailServer(this Configuration configuration, string name, Action <MailServerConfiguration> action)
{
var emailConfig = new MailServerConfiguration();
action(emailConfig);
configuration.Configurations.Add(name, emailConfig);
return(configuration);
}
public static Configuration AddMailServer(this Configuration configuration, Action <MailServerConfiguration> action)
{
var emailConfig = new MailServerConfiguration();
action(emailConfig);
configuration.Configurations.Add(Constants.DefaulMailServerConfigName, emailConfig);
return(configuration);
}
public void Initialize(MailServerConfiguration configuration)
{
this.cfg = configuration;
this.smtp = new SmtpClient()
{
Host = configuration.SMTP,
Port = configuration.Port,
Credentials = new NetworkCredential(configuration.Account, configuration.Password),
EnableSsl = configuration.UseSSL
};
}
private NetMail.SmtpClient CreateClient(MailServerConfiguration config)
{
NetMail.SmtpClient client;
if (config.Port > 0)
{
client = new NetMail.SmtpClient(config.Hostname, config.Port);
}
else
{
client = new NetMail.SmtpClient(config.Hostname);
}
if (!string.IsNullOrEmpty(config.Username) && !string.IsNullOrEmpty(config.Password))
{
client.Credentials = new NetworkCredential(config.Username, config.Password);
}
client.EnableSsl = config.EnableSsl;
return(client);
}
public ClientRegistrationResponse Post([FromBody] ClientRegistrationRequest request)
{
try
{
_logger.Info("register new client: ");
_logger.Info(JsonConvert.SerializeObject(request, Formatting.Indented));
var loginName = $"{request.FirstName[0].ToString().ToLowerInvariant()}.{request.LastName.ToLowerInvariant()}";
var clientId = _userService.CreateClient(new RegisteredClient
{
Country = request.Country,
State = RegisteredClientState.Pending,
CreationUser = loginName,
CreationDate = DateTime.Now,
});
var workContext = new WorkContext {
UserId = Guid.Empty, LoginName = loginName
};
var user = _userService.CreateUser(workContext, new User
{
RegisteredClientId = clientId,
LoginName = loginName,
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
EmailIsValidated = false,
Password = request.EncryptedPassword,
PasswordLastChangedDate = DateTime.Now,
IsActive = true,
});
var mailServerConfig = new MailServerConfiguration
{
Hostname = "smtp.gmail.com",
Port = 587,
Username = "******",
Password = "******",
From = "*****@*****.**",
EnableSsl = true,
IsActive = true
};
var renderedMessage = _mailService.RenderMailContent("0000000000", "AppSolutions", "NewClientRegistrationUserMailAddressValidation", "EN", new
{
FirstName = request.FirstName,
LastName = request.LastName,
MailAddress = request.Email,
VerificationLink = $"http://localhost:29328/User/EmailVerification/{clientId}/{user.UserId}"
});
var message = new MailMessage
{
From = new MailAddress {
Address = mailServerConfig.From
},
To = new List <MailAddress> {
new MailAddress {
Address = request.Email
}
},
IsBodyHtml = renderedMessage.IsBodyHtml,
Subject = renderedMessage.Subject,
Body = renderedMessage.Body,
};
_mailService.SendMail(mailServerConfig, message);
return(ClientRegistrationResponse.Success(clientId, request.Email));
}
catch (Exception e)
{
_logger.Error(e);
return(ClientRegistrationResponse.Error(e));
}
}
/// <summary>
/// Creates a rasp mail handler
/// </summary>
/// <param name="bindingContext">the binding context</param>
/// <returns>a rasp mail handler</returns>
public static RaspMailHandler GetRaspMailHandlerFromBindingContext(BindingContext bindingContext)
{
// Get the mail binding from the context
RaspEmailBindingElement mailBinding = (RaspEmailBindingElement)bindingContext.Binding.Elements.Find <RaspEmailBindingElement>();
if (mailBinding == null)
{
throw new RaspEmailBindingElemenNotFoundtException();
}
// Get the type of the outbox implementation
Type outBoxImplementationType = Type.GetType(mailBinding.OutboxImplementation);
if (outBoxImplementationType == null)
{
throw new RaspMailboxImplementationCouldNotBeFoundException("outbox");
}
// Get the type of the inbox implementation
Type inBoxImplementationType = Type.GetType(mailBinding.InboxImplementation);
if (inBoxImplementationType == null)
{
throw new RaspMailboxImplementationCouldNotBeFoundException("inbox");
}
// Read the connection policy from config
MailServerConnectionPolicy inboxConnectionPolicy = new MailServerConnectionPolicy();
if (mailBinding.PollingInterval != null && mailBinding.PollingInterval != TimeSpan.Zero)
{
inboxConnectionPolicy.PollingInterval = mailBinding.PollingInterval;
}
inboxConnectionPolicy.AuthenticationMode = mailBinding.ReceivingAuthenticationMode;
inboxConnectionPolicy.Port = mailBinding.ReceivingPort;
MailServerConnectionPolicy outboxConnectionPolicy = new MailServerConnectionPolicy();
outboxConnectionPolicy.PollingInterval = inboxConnectionPolicy.PollingInterval;
outboxConnectionPolicy.AuthenticationMode = mailBinding.SendingAuthenticationMode;
outboxConnectionPolicy.Port = mailBinding.SendingPort;
MailServerConfiguration recievingServerConfiguration = new MailServerConfiguration(
mailBinding.ReceivingServerAddress,
mailBinding.ReceivingUserName,
mailBinding.ReceivingPassword,
mailBinding.ReplyAddress,
inboxConnectionPolicy);
MailServerConfiguration sendingServerConfiguration = new MailServerConfiguration(
mailBinding.SendingServerAddress,
mailBinding.SendingUserName,
mailBinding.SendingPassword,
mailBinding.ReplyAddress,
outboxConnectionPolicy);
MailHandlerConfiguration handlerConfiguration = new MailHandlerConfiguration(
outBoxImplementationType,
inBoxImplementationType,
sendingServerConfiguration,
recievingServerConfiguration);
return(new RaspMailHandler(handlerConfiguration));
}
public MailServiceOperationResponse SendMail(MailServerConfiguration server, MailMessage message)
{
ArgumentCheck.IsNotNull(server, $"{nameof(server)} must not be null");
ArgumentCheck.IsNotNullOrEmpty(server.Hostname, $"{nameof(server.Hostname)} must not be null or empty");
ArgumentCheck.IsNotNullOrEmpty(server.From, $"{nameof(server.From)} must not be null or empty");
ArgumentCheck.IsNotNull(message, $"{nameof(message)} must not be null");
ArgumentCheck.IsNotNull(message.To, $"{nameof(message.To)} must not be null");
ArgumentCheck.IsTrue(message.To.Count > 0, $"{nameof(message.To)} must contain at least 1 address");
ArgumentCheck.IsFalse(message.To.Any(o => string.IsNullOrEmpty(o.Address)), $"{nameof(MailAddress.Address)} fields must not be null or empty");
ArgumentCheck.IsNotNullOrEmpty(message.Body, $"{nameof(message.Body)}");
ArgumentCheck.IsNotNullOrEmpty(message.Subject, $"{nameof(message.Subject)}");
try
{
NetMail.MailMessage netMessage = new NetMail.MailMessage();
// TO ##########################
if (message.From == null)
{
netMessage.From = new NetMail.MailAddress(message.From.Address);
}
else
{
netMessage.From = new NetMail.MailAddress(server.From);
}
// TO ##########################
foreach (var adr in message.To)
{
if (string.IsNullOrEmpty(adr.Address))
{
continue;
}
NetMail.MailAddress address = new NetMail.MailAddress(adr.Address);
if (!string.IsNullOrEmpty(adr.DisplayName))
{
address = new NetMail.MailAddress(adr.Address, adr.DisplayName);
}
netMessage.To.Add(address);
}
// CC ##########################
if (message.CC != null)
{
foreach (var adr in message.CC)
{
if (string.IsNullOrEmpty(adr.Address))
{
continue;
}
NetMail.MailAddress address = new NetMail.MailAddress(adr.Address);
if (!string.IsNullOrEmpty(adr.DisplayName))
{
address = new NetMail.MailAddress(adr.Address, adr.DisplayName);
}
netMessage.CC.Add(address);
}
}
// BCC ##########################
if (message.Bcc != null)
{
foreach (var adr in message.Bcc)
{
if (string.IsNullOrEmpty(adr.Address))
{
continue;
}
NetMail.MailAddress address = new NetMail.MailAddress(adr.Address);
if (!string.IsNullOrEmpty(adr.DisplayName))
{
address = new NetMail.MailAddress(adr.Address, adr.DisplayName);
}
netMessage.Bcc.Add(address);
}
}
// ################################
netMessage.Subject = message.Subject;
netMessage.Body = message.Body;
netMessage.IsBodyHtml = message.IsBodyHtml;
// ################################
using (NetMail.SmtpClient client = CreateClient(server))
{
client.Send(netMessage);
}
_logger.Info($"Mail sent: '{message.Subject}' to '{string.Join(';', message.To.Select(o => o.Address).ToList())}'");
return(MailServiceOperationResponse.CreateSuccess());
}
catch (Exception e)
{
_logger.Error(e);
return(MailServiceOperationResponse.CreateInternalServerError(e));
}
}
