public void SendEmail_DeserializeObject()
        {
            var base64 =
                Convert.ToBase64String(
                    Encoding.UTF8.GetBytes("<h1>Title</h1><p>This is the mail body.</p>")
                    );

            var command = new SendMailCommand(
                "*****@*****.**",
                subject: "subject",
                message: base64
                );

            var text = MaskedEmailCommandJsonConvert.SerializeObject(command);

            var o = MaskedEmailCommandJsonConvert.DeserializeObject(text);

            Assert.AreEqual(command.Action, o.Action);
            Assert.AreEqual(command.Address, o.Address);

            var c = o as SendMailCommand;

            Assert.AreEqual(command.Subject, c.Subject);
            Assert.AreEqual(command.Message, c.Message);
        }
Exemple #2
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="state"></param>
 /// <param name="command"></param>
 /// <param name="invalidMailAddressList"></param>
 public SendMailResult(SendMailResultState state, SendMailCommand command, String message, IEnumerable<MailAddress> invalidMailAddressList)
 {
     this.Command = command;
     this.State = state;
     this.Message = message;
     this.InvalidMailAddressList.AddRange(invalidMailAddressList);
 }
Exemple #3
0
        public async Task SendAsync(SendMailCommand mailDto, ProviderSettings settings)
        {
            string cacheTokenName = $"{settings.Name ?? ""}_token";
            var    token          = _memoryCache.Get <Token>(cacheTokenName);

            if (token == null || token.HasExpired)
            {
                token = await _authService.GetTokenAsync(new AzureAdOptions
                {
                    Tenant        = settings.Tenant,
                    ClientId      = settings.ClientId,
                    ClientSecret  = settings.ClientSecret,
                    Instance      = "https://login.microsoftonline.com/",
                    GraphResource = "https://graph.microsoft.com"
                });

                _memoryCache.Set(cacheTokenName, token);
            }

            string from = mailDto.From ?? settings.DefaultFrom;

            if (string.IsNullOrEmpty(from))
            {
                throw new Exception("From is required");
            }

            await $"{_azureAdOptions.GraphResource}/beta/users/{from}/sendMail"
            .WithOAuthBearerToken(token.AccessToken)
            .PostJsonAsync(new
            {
                message = new {
                    subject = mailDto.Subject,
                    body    = new
                    {
                        contentType = mailDto.IsHtml ? "HTML" : "Text",
                        content     = mailDto.Body
                    },
                    toRecipients = mailDto.To?.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                                   .Select(v => new
                    {
                        emailAddress = new
                        {
                            address = v
                        }
                    }),
                    ccRecipients = (IEnumerable)mailDto.Cc?.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                                   .Select(v => new
                    {
                        emailAddress = new
                        {
                            address = v
                        }
                    }) ?? new string[] {}
                },
                saveToSentItems = "false"
            });
        }
		public void the_from_part_should_include_display_name()
		{
			var cmd = new SendMailCommand(
				new MailgunClient("domain", "api"), 
				new MailMessage(
					new MailAddress("*****@*****.**", "Gino Heyman"),
					new MailAddress("*****@*****.**", "Gino Heyman")) 
					{ Body = "this is a test message from mailgun.", Subject = "Hello from mailgun" });

			Assert.AreEqual("\"Gino Heyman\" <*****@*****.**>", ((SimpleFormPart)cmd.CreateFormParts().First(p => p is SimpleFormPart)).Value);
		}
        public async Task Handle(SendMailEvent message)
        {
            var command = new SendMailCommand
            {
                To            = message.To,
                TemplateID    = message.TemplateID,
                ProjectApiKey = message.ProjectApiKey
            };

            await _mediator.Send(command);
        }
        public void the_from_part_should_include_display_name()
        {
            var cmd = new SendMailCommand(
                new MailgunClient("domain", "api"),
                new MailMessage(
                    new MailAddress("*****@*****.**", "Gino Heyman"),
                    new MailAddress("*****@*****.**", "Gino Heyman"))
            {
                Body = "this is a test message from mailgun.", Subject = "Hello from mailgun"
            });

            Assert.AreEqual("\"Gino Heyman\" <*****@*****.**>", ((SimpleFormPart)cmd.CreateFormParts().First(p => p is SimpleFormPart)).Value);
        }
Exemple #7
0
        public virtual async Task <ActionResult> SendMailAsync([FromBody] SendMailCommand command)
        {
            if (command == null)
            {
                command = new SendMailCommand();
            }

            var hasMailSent = await _mediator.Send(command);

            if (!hasMailSent)
            {
                return(NotFound());
            }

            return(Ok());
        }
Exemple #8
0
        public void SendMailCommand_FormatCommandLine()
        {
            var base64 =
                Convert.ToBase64String(
                    Encoding.UTF8.GetBytes("<h1>Title</h1><p>This is the mail body.</p>")
                    );

            var command = new SendMailCommand(
                recipient: "*****@*****.**",
                subject: "A `subject` \\with\\ \"quoted\" $characters",
                message: base64
                );

            var commandLines = MaskedEmailCommandLineFormatter.Format(command);

            Assert.AreEqual(1, commandLines.Length);
            Assert.AreEqual($"/usr/local/bin/send-email -address [email protected] -subject \"A \\`subject\\` \\\\with\\\\ \\\"quoted\\\" \\$characters\" -message {base64}", commandLines[0]);
        }
        public async Task Deve_Enviar_Email_Com_Template_ComSucesso()
        {
            var model = new SendMailCommand
            {
                To         = "*****@*****.**",
                TemplateID = await CriarTemplate()
            };

            model.KeyValues.Add(new KeyValuePair <string, string>("{nome}", "danilo dumba"));
            model.KeyValues.Add(new KeyValuePair <string, string>("{email}", "*****@*****.**"));
            model.KeyValues.Add(new KeyValuePair <string, string>("{teste}", "Coisa boa!"));

            var projeto = await this.projectService.ObterProjeto();

            model.ProjectApiKey = projeto.ApiKey;

            var response = await this.Post(model);

            Assert.True(response.IsSuccessStatusCode, await response.Content.ReadAsStringAsync());
        }
Exemple #10
0
        public async Task SendAsync(SendMailCommand mailDto, ProviderSettings settings)
        {
            var message = mailDto.ToMimeMessage(settings.Smtp);

            if (!_smtpClient.IsAuthenticated || !_smtpClient.IsConnected)
            {
                _smtpClient.LocalDomain = settings.Smtp.LocalDomain;
                await _smtpClient.ConnectAsync(settings.Smtp.Host, settings.Smtp.Port, settings.Smtp.SecureSocketOptions).ConfigureAwait(false);

                if (settings.Smtp.User != null && settings.Smtp.Password != null)
                {
                    _smtpClient.Authenticate(settings.Smtp.User, settings.Smtp.Password);
                }
            }
            await _smtpClient.SendAsync(message).ConfigureAwait(false);

            if (!settings.KeepConnection)
            {
                await _smtpClient.DisconnectAsync(true).ConfigureAwait(false);
            }
        }
Exemple #11
0
        SendMailResponse IEasConnection.SendMail(SendMailRequest sendMailRequest)
        {
            SendMailCommand sendMailCommand = new SendMailCommand(this.EasConnectionSettings);

            return(sendMailCommand.Execute(sendMailRequest));
        }
        public async Task <IActionResult> Post([FromBody] SendMailCommand command)
        {
            await _mediator.Send(command);

            return(NoContent());
        }
Exemple #13
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="state"></param>
 /// <param name="command"></param>
 public SendMailResult(SendMailResultState state, SendMailCommand command)
 {
     this.Command = command;
     this.State = state;
     this.Message = "";
 }
 public ConcreteSendMailCommand(SendMailCommand command)
     : base(command)
 {
     _sendMailCommand = command;
 }
Exemple #15
0
 /// メールを送信し、送信結果となるSendMailListResultを取得します。
 /// <summary>
 /// メールを送信し、送信結果となるSendMailListResultを取得します。
 /// </summary>
 /// <param name="command"></param>
 /// <returns></returns>
 public SendMailResult SendMail(SendMailCommand command)
 {
     var l = this.SendMailList(new[] { command });
     if (l.Results.Count == 1)
     {
         return new SendMailResult(l.Results[0].State, command);
     }
     return new SendMailResult(l.State, command);
 }
Exemple #16
0
 public Result SendMail(SendMailCommand sendMailCommand)
 {
     throw new NotImplementedException();
 }