public SendConfirmationCommandHandler(IConfirmationService confirmation, IKafkaMessageBus bus,
IEmailBuilder emailBuilder)
{
_confirmation = confirmation;
_bus = bus;
_emailBuilder = emailBuilder;
}
public UserConfirmationEmailTests(AuthenticationFixture fixture)
{
_user = fixture.TestUser;
_mockEmailBuilder = fixture.EmailBuilder;
_mockEventBus = fixture.EventBus;
_mockUserManager = fixture.UserManager;
}
public RequestController(IRequestService <RequestUserModel,
RequestViewModel <RequestUserModel> > requestService,
IRequestSecurityService <RequestUserModel> securityService,
IEmailBuilder emailBuilder,
IEmailSender emailSender, Infrastructure.Logging.ILogger logger)
{
if (requestService == null)
{
throw new ArgumentNullException("requestService");
}
_requestService = requestService;
if (securityService == null)
{
throw new ArgumentNullException("securityService");
}
_securityService = securityService;
if (emailBuilder == null)
{
throw new ArgumentNullException("emailBuilder");
}
_emailBuilder = emailBuilder;
if (emailSender == null)
{
throw new ArgumentNullException("emailSender");
}
_emailSender = emailSender;
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
}
public ForgotPasswordCommandHandler(UserManager <AppUser> userManager, IEmailBuilder emailBuilder,
IEventBus eventBus)
{
_userManager = userManager;
_emailBuilder = emailBuilder;
_eventBus = eventBus;
}
private static EmailMessageData CreateMessage(
IEmailBuilder emailBuilder,
bool copySender = false,
bool discloseSenderAddress = false)
{
var recipients = emailBuilder.GetRecipients();
if (recipients == EmailRecipients.None)
{
// Optimization: no need to construct message body when no recipients.
return(null);
}
if (emailBuilder.Sender == null)
{
throw new ArgumentException(
$"No sender defined for message of type '{emailBuilder.GetType()}'.",
nameof(emailBuilder.Sender));
}
return(new EmailMessageData(
emailBuilder.GetSubject(),
emailBuilder.GetBody(EmailFormat.PlainText),
emailBuilder.GetBody(EmailFormat.Html),
emailBuilder.Sender.Address,
to: recipients.To.Select(e => e.Address).ToList(),
cc: GenerateCC(
emailBuilder.Sender.Address,
recipients.CC.Select(e => e.Address).ToList(),
copySender,
discloseSenderAddress),
bcc: recipients.Bcc.Select(e => e.Address).ToList(),
replyTo: recipients.ReplyTo.Select(e => e.Address).ToList(),
messageTrackingId: Guid.NewGuid()));
}
private EmailMessageData CreateMessage(
IEmailBuilder emailBuilder,
bool copySender = false,
bool discloseSenderAddress = false)
{
var recipients = emailBuilder.GetRecipients();
if (!recipients.To.Any())
{
_logger.LogInformation("Cannot create message to send as it has no recipients.");
return(null);
}
if (emailBuilder.Sender == null)
{
throw new ArgumentException(
$"No sender defined for message of type '{emailBuilder.GetType()}'.",
nameof(emailBuilder.Sender));
}
return(new EmailMessageData(
emailBuilder.GetSubject(),
emailBuilder.GetBody(EmailFormat.PlainText),
emailBuilder.GetBody(EmailFormat.Html),
emailBuilder.Sender.Address,
to: recipients.To.Select(e => e.Address).ToList(),
cc: GenerateCC(
emailBuilder.Sender.Address,
recipients.CC.Select(e => e.Address).ToList(),
copySender,
discloseSenderAddress),
bcc: recipients.Bcc.Select(e => e.Address).ToList(),
replyTo: recipients.ReplyTo.Select(e => e.Address).ToList(),
messageTrackingId: Guid.NewGuid()));
}
public async Task SendMessageAsync(
IEmailBuilder emailBuilder,
bool copySender = false,
bool discloseSenderAddress = false)
{
if (emailBuilder == null)
{
throw new ArgumentNullException(nameof(emailBuilder));
}
_logger.LogInformation("Sending message with CopySender {CopySender} and DiscloseSenderAddress {DiscloseSenderAddress}",
copySender, discloseSenderAddress);
var message = CreateMessage(
emailBuilder,
copySender,
discloseSenderAddress);
await EnqueueMessageAsync(message);
// If we're asked to copy the sender but cannot disclose the sender address,
// we should send a separate email to the sender.
// The case where copySender=true and discloseSenderAddress=true is handled by the respective message,
// which may add the sender to the CC recipients.
if (copySender && !discloseSenderAddress)
{
await EnqueueMessageToSenderAsync(emailBuilder);
}
}
public HttpEmailClient(ILogger <HttpEmailClient> logger, IEmailBuilder emailBuilder, IAmazonSimpleEmailService amazonSimpleEmailService, bool sendAmazonEmails)
{
_logger = logger;
_emailBuilder = emailBuilder;
_amazonSimpleEmailService = amazonSimpleEmailService;
_sendAmazonEmails = sendAmazonEmails;
}
public RequestDelegatePermissionsController(
IRequestDelegatePermissionsService requestService,
IRequestSecurityService <RequestDelegatePermissionsUserModel> securityService,
IEmailBuilder emailBuilder, IEmailSender emailSender,
ILogger logger)
{
if (requestService == null)
{
throw new ArgumentNullException("requestService");
}
_requestService = requestService;
if (securityService == null)
{
throw new ArgumentNullException("securityService");
}
_securityService = securityService;
if (emailBuilder == null)
{
throw new ArgumentNullException("emailBuilder");
}
_emailBuilder = emailBuilder;
if (emailSender == null)
{
throw new ArgumentNullException("emailSender");
}
_emailSender = emailSender;
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
}
public Task SendMail(EmailBase email)
{
IMailClient mailClient = _emailFactory.CreateMailClient();
IEmailBuilder emailBuilder = _emailFactory.CreateEmailBuilder();
_emailInitializer.Initialize(emailBuilder, email);
return(mailClient.SendAsync(emailBuilder));
}
public ResetPasswordCommandHandler(UserManager <AppUser> userManager, IEventBus eventBus,
IEmailBuilder emailBuilder, IFailedIdentityResult failedIdentityResult)
{
_userManager = userManager;
_eventBus = eventBus;
_emailBuilder = emailBuilder;
_failedIdentityResult = failedIdentityResult;
}
public EmailService(
IEmailBuilder emailBuilder,
IEmailDistributionService emailDistributionService,
IEmailDeliveryService emailDeliveryService)
{
_emailBuilder = emailBuilder;
_emailDistributionService = emailDistributionService;
_emailDeliveryService = emailDeliveryService;
}
public EmailService(IEmailBuilder builder, IConfiguration configuration)
{
_builder = builder;
_apiKey = configuration["SENDGRID_API_KEY"];
SenderEmail = configuration["SENDGRID_EMAIL"];
_senderName = configuration["SENDGRID_Name"];
SupportEmail = configuration["SupportEmailAddress"];
}
public Task SendMessageAsync(IEmailBuilder emailBuilder, bool copySender = false, bool discloseSenderAddress = false)
{
_logger.LogInformation("Message Sending with Subject: {Subject}", emailBuilder.GetSubject());
_logger.LogInformation("Body: {Body}", emailBuilder.GetBody(EmailFormat.PlainText));
_logger.LogInformation("Sender: {Sender}", emailBuilder.Sender.Address);
_logger.LogWarning("Empty messenger used. Sending a message is no-oping.");
return(Task.CompletedTask);
}
public void Setup()
{
builder = MockRepository.GenerateStub<IEmailBuilder>();
sender = MockRepository.GenerateStub<IEmailSender>();
baseControllerService = MockRepository.GenerateStub<IBaseControllerService>();
baseControllerService.ShopName = "Suteki Shop";
baseControllerService.EmailAddress = "*****@*****.**";
service = new EmailService(builder, sender, baseControllerService);
}
public void Setup()
{
builder = MockRepository.GenerateStub <IEmailBuilder>();
sender = MockRepository.GenerateStub <IEmailSender>();
baseControllerService = MockRepository.GenerateStub <IBaseControllerService>();
baseControllerService.ShopName = "Suteki Shop";
baseControllerService.EmailAddress = "*****@*****.**";
service = new EmailService(builder, sender, baseControllerService);
}
public Task SendMails(IEnumerable <EmailBase> mailList)
{
return(Task.WhenAll(mailList.Select(email =>
{
IMailClient mailClient = _emailFactory.CreateMailClient();
IEmailBuilder emailBuilder = _emailFactory.CreateEmailBuilder();
_emailInitializer.Initialize(emailBuilder, email);
return mailClient.SendAsync(emailBuilder);
})));
}
public void ContructorShouldThrowArgumentNullExceptionWhenNullParameterGiven(IOptions <SmtpConfiguration> smtpConfiguration,
ISmtpClient smtpClient,
IEmailBuilder emailBuilder,
IOptions <NotificationConfiguration> notificationConfiguration)
{
Assert.Throws <ArgumentNullException>(() => new EmailNotificationService(smtpConfiguration,
smtpClient,
emailBuilder,
notificationConfiguration,
_loggerMock.Object));
}
public ForgotPasswordCommandHandlerTests(AuthenticationFixture fixture)
{
_mockUserManager = fixture.UserManager;
_mockEmailBuilder = fixture.EmailBuilder;
_mockEventBus = fixture.EventBus;
_user = fixture.TestUser;
_query = new ForgotPasswordQuery
{
Email = "*****@*****.**"
};
}
internal PersonBuilder(GeneratorSettings settings)
{
firstNameBuilder = GetFirstNameBuilder(settings);
middleNameBuilder = GetMiddleNameBuilder(settings);
lastNameBuilder = GetLastNameBuilder(settings);
genderBuilder = GetGenderBuilder(settings);
ageBuilder = GetAgeBuilder(settings);
birthDateBuilder = GetBirthDateBuilder(settings);
countryBuilder = GetCountryBuilder(settings);
emailBuilder = GetEmailBuilder(settings);
phoneNumberBuilder = GetPhoneNumberBuilder(settings);
}
public static EmailMessage ConstructEmail(IEmailBuilder builder)
{
builder.BuildHtmlContent();
builder.BuildPlainTextContent();
builder.BuildRecipient();
builder.BuildRecipientName();
builder.BuildSender();
builder.BuildSenderName();
builder.BuildSubject();
return(builder.BuildEmail());
}
public MailKitEmailService(IEmailConfiguration emailConfiguration, ILogger <MailKitEmailService> logger)
{
_emailConfiguration = emailConfiguration;
_emailContainerItems = new List <EmailContainerItem>();
_emailBuilder = new MailKitEmailBuilder();
_fromMailAddress = new EmailAddress()
{
Address = emailConfiguration.FromMailAddress
};
_mailMessageHandler = new MailMessageHandler();
_logger = logger;
}
public UserService(IMapper mapper,
DreamFoodDeliveryContext context,
UserManager <AppUser> userManager,
IEmailSenderService emailSender,
IEmailBuilder emailBuilder)
{
_context = context;
_mapper = mapper;
_userManager = userManager;
_emailSender = emailSender;
_emailBuilder = emailBuilder;
}
public UserService(BuilderContext context,
IMapper mapper,
IEmailService emailService,
IEmailBuilder emailBuilder,
IFileProvider fileProvider)
{
_context = context;
_mapper = mapper;
_emailService = emailService;
_emailBuilder = emailBuilder;
_fileProvider = fileProvider;
}
public async Task SendMessageAsync(IEmailBuilder emailBuilder, bool copySender = false, bool discloseSenderAddress = false)
{
if (emailBuilder == null)
{
throw new ArgumentNullException(nameof(emailBuilder));
}
using (var email = CreateMailMessage(emailBuilder))
{
await SendMessageInternalAsync(email, copySender, discloseSenderAddress);
}
}
public SendNotificationKernalService(
ILogger <SendNotificationKernalService> logger,
IQueryRepository <NotificationType> queryRepository,
IChannelAudienceResolverProvider channelAudienceResolverProvider,
ITransactionManager transactionManager,
IEmailBuilder emailBuilder)
{
_logger = logger;
_queryRepository = queryRepository;
_channelAudienceResolverProvider = channelAudienceResolverProvider;
_transactionManager = transactionManager;
_emailBuilder = emailBuilder;
}
public RegisterModel(UserManager <ChronicyUser> userManager,
//SignInManager<ChronicyUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
IEmailBuilder emailBuilder)
{
this.userManager = userManager;
//this.signInManager = signInManager;
this.logger = logger;
this.emailSender = emailSender;
this.emailBuilder = emailBuilder;
}
public TeamMemberService(
BuilderContext context,
IMapper mapper,
IUserService userService,
IEmailBuilder emailBuilder,
IEmailService emailService,
INotificationsService notificationsService) : base(context, mapper)
{
_context = context;
_userService = userService;
_emailBuilder = emailBuilder;
_emailService = emailService;
_notificationsService = notificationsService;
}
public EmailService(UserManager<IUserDto, int> userManager, IEmailBuilder emailBuilder)
{
if (userManager == null)
{
throw new ArgumentNullException("userManager");
}
if (emailBuilder == null)
{
throw new ArgumentNullException("emailBuilder");
}
_userManager = userManager;
_emailBuilder = emailBuilder;
}
public CustomerService(ICustomerRepository repository, IEmailBuilder emailBuilder,
IIdFactory idFactory, IMailingAddressFactory mailingAddressFactory, INameBuilder nameBuilder, ICustomerStatusFactory statusFactory,
IWorkstationSettings workstationSettings)
{
_repositry = repository;
_emailBuilder = emailBuilder;
_idFactory = idFactory;
_mailingAddressFactory = mailingAddressFactory;
_nameBuilder = nameBuilder;
_statusFactory = statusFactory;
_workstationSettings = workstationSettings;
// установка обработчика события
_repositry.Notify += (o, e) => _mailingAddressFactory.CreatenewMessage(e.CustomerName);
}
public ResetPasswordCommandHandlerTests(AuthenticationFixture fixture)
{
_mockEventBus = fixture.EventBus;
_mockUserManager = fixture.UserManager;
_mockEmailBuilder = fixture.EmailBuilder;
_mockFailedIdentityResult = fixture.FailedIdentityResult;
_user = fixture.TestUser;
_command = new ResetPasswordCommand
{
Email = "*****@*****.**",
NewPassword = "******",
ResetPasswordToken = "10101010"
};
}
public Task SendAsync(IEmailBuilder emailBuilder)
{
var message = (MailMessageBuilder)emailBuilder;
try
{
_smtpClient.Send(message.GetResult());
}
finally
{
message.Dispose();
_smtpClient.Dispose();
}
return Task.FromResult(0);
}
public Task SendAsync(IEmailBuilder emailBuilder)
{
var message = (MailMessageBuilder)emailBuilder;
try
{
_smtpClient.Send(message.GetResult());
}
finally
{
message.Dispose();
_smtpClient.Dispose();
}
return(Task.FromResult(0));
}
public void Initialize(IEmailBuilder emailBuilder, EmailBase email)
{
emailBuilder.SetSender(email.From);
emailBuilder.SetContent(email.Subject, email.Content, email.ContentType);
if (email.Headers.Count > 0)
emailBuilder.AddToWithHeader(email.Headers);
foreach (EmailAddress emailAddress in email.To)
{
emailBuilder.AddToRecipient(emailAddress);
}
foreach (EmailAddress emailAddress in email.Cc)
{
emailBuilder.AddCcRecipient(emailAddress);
}
foreach (EmailAddress emailAddress in email.Bcc)
{
emailBuilder.AddBccRecipient(emailAddress);
}
}
public EmailNotification(IEmailBuilder emailBuilder)
{
_emailBuilder = emailBuilder;
}
public EmailManager(IEmailBuilder mailer)
{
_mailer = mailer;
}
public void Setup()
{
builder = new EmailBuilder("Services\\Templates");
}
public EmailService(IEmailBuilder builder, IEmailSender sender, IBaseControllerService service)
{
this.builder = builder;
this.sender = sender;
this.baseService = service;
}
public EmailServiceTest()
{
_userManager = A.Fake<UserManager<IUserDto, int>>();
_emailBuilder = A.Fake<IEmailBuilder>();
_emailService = new EmailService(_userManager, _emailBuilder);
}
