FromMessage(HttpResponseMessage message)
137 | {
138 | var response = new QuickFile();
139 | response.Message = message;
140 | response.ResponseBody = await message.Content.ReadAsStringAsync();
141 |
142 | if (message.IsSuccessStatusCode)
143 | {
144 | response.Data = await message.Content.ReadAsStreamAsync();
145 | }
146 | else
147 | {
148 | response.HandleFailedCall();
149 | }
150 |
151 | return response;
152 | }
153 | }
154 | }
155 |
--------------------------------------------------------------------------------
/test/FluentEmail.ThirdParty.Tests/MailtrapSenderTests.cs:
--------------------------------------------------------------------------------
1 | using FluentEmail.Core;
2 | using FluentEmail.Core.Tests;
3 | using FluentEmail.Mailtrap;
4 |
5 | namespace FluentEmail.ThirdParty.Tests;
6 |
7 | public class MailtrapSenderTests
8 | {
9 | private const string Subject = "Mailtrap Email Test";
10 | private const string Body = "This email is testing the functionality of mailtrap.";
11 |
12 | private readonly string _toEmail = Credentials.MailTrap.ToEmail ?? Credentials.ToEmail;
13 | private readonly string _fromEmail = Credentials.MailTrap.FromEmail ?? Credentials.FromEmail;
14 | private readonly string _host = Credentials.MailTrap.Host;
15 | private readonly string _username = Credentials.MailTrap.User;
16 | private readonly int _port = Credentials.MailTrap.Port ?? 587;
17 | private readonly string _password = Credentials.MailTrap.Password;
18 | private readonly string _apiHost = Credentials.MailTrap.ApiHost;
19 | private readonly string _apiKey = Credentials.MailTrap.ApiKey;
20 | private readonly string _templateId = Credentials.MailTrap.Template;
21 |
22 | private ISender Sender { get; }
23 |
24 | public MailtrapSenderTests()
25 | {
26 | if (!string.IsNullOrEmpty(_username)) Sender = new MailtrapSender(_username, _password, _host, _port);
27 | }
28 |
29 | [Fact]
30 | public void CanSendEmail()
31 | {
32 | Assert.SkipWhen(string.IsNullOrEmpty(_password), "No Mailtrap Credentials");
33 |
34 | var email = Email
35 | .From(_fromEmail)
36 | .To(_toEmail)
37 | .Subject(Subject)
38 | .Body(Body);
39 |
40 | email.Sender = Sender;
41 | var response = email.Send();
42 |
43 | (response.Successful).Should().BeTrue();
44 | }
45 |
46 |
47 | [Fact]
48 | public async Task CanSendEmailAsync()
49 | {
50 | Assert.SkipWhen(string.IsNullOrEmpty(_password), "No Mailtrap Credentials");
51 |
52 | var email = Email
53 | .From(_fromEmail)
54 | .To(_toEmail)
55 | .Subject(Subject)
56 | .Body(Body);
57 |
58 | email.Sender = Sender;
59 | var response = await email.SendAsync();
60 |
61 | (response.Successful).Should().BeTrue();
62 | }
63 |
64 | [Fact]
65 | public async Task CanSendEmailWithAttachments()
66 | {
67 | Assert.SkipWhen(string.IsNullOrEmpty(_password), "No Mailtrap Credentials");
68 |
69 | var stream = new MemoryStream();
70 | var sw = new StreamWriter(stream);
71 | await sw.WriteLineAsync("Hey this is some text in an attachment");
72 | await sw.FlushAsync(TestContext.Current.CancellationToken);
73 | stream.Seek(0, SeekOrigin.Begin);
74 |
75 | var attachment = new Attachment
76 | {
77 | Data = stream,
78 | ContentType = "text/plain",
79 | Filename = "mailtrapTest.txt"
80 | };
81 |
82 | var email = Email
83 | .From(_fromEmail)
84 | .To(_toEmail)
85 | .Subject(Subject)
86 | .Body(Body)
87 | .Attach(attachment);
88 |
89 | email.Sender = Sender;
90 | var response = await email.SendAsync();
91 |
92 | (response.Successful).Should().BeTrue();
93 | }
94 |
95 | [Fact]
96 | public async Task CanSendEmailWithInlineImages()
97 | {
98 | Assert.SkipWhen(string.IsNullOrEmpty(_password), "No Mailtrap Credentials");
99 |
100 | await using var stream = File.OpenRead($"{Path.Combine(Directory.GetCurrentDirectory(), "logotest.png")}");
101 | var attachment = new Attachment
102 | {
103 | IsInline = true,
104 | Data = stream,
105 | ContentType = "image/png",
106 | Filename = "logotest.png"
107 | };
108 |
109 | var email = Email
110 | .From(_fromEmail)
111 | .To(_toEmail)
112 | .Subject(Subject)
113 | .Body("Inline image here: ![](\"cid:logotest.png\")
" +
114 | "You should see an image without an attachment, or without a download prompt, depending on the email client.
", true)
115 | .Attach(attachment);
116 |
117 | email.Sender = Sender;
118 | var response = await email.SendAsync();
119 |
120 | (response.Successful).Should().BeTrue();
121 | }
122 |
123 | [Fact]
124 | public async Task CanSendEmailWithTemplate()
125 | {
126 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailtrap Credentials");
127 |
128 | var email = Email.From(_fromEmail).To(_toEmail);
129 | email.Sender = new MailtrapSender(_username, _apiKey, _host, 587, _apiHost);
130 |
131 | // ReSharper disable once StringLiteralTypo
132 | var response = await email.SendWithTemplateAsync(_templateId, new { var1 = "Test", var2 = "VVVVVVVVVVVVV" });
133 |
134 | (response.Successful).Should().BeTrue();
135 | }
136 | }
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | ## Ignore Visual Studio temporary files, build results, and
2 | ## files generated by popular Visual Studio add-ons.
3 |
4 | # User-specific files
5 | *.suo
6 | *.user
7 | *.userosscache
8 | *.sln.docstates
9 | appsettings.development.json
10 |
11 | # User-specific files (MonoDevelop/Xamarin Studio)
12 | *.userprefs
13 |
14 | # Build results
15 | [Dd]ebug/
16 | [Dd]ebugPublic/
17 | [Rr]elease/
18 | [Rr]eleases/
19 | [Xx]64/
20 | [Xx]86/
21 | [Bb]uild/
22 | bld/
23 | [Bb]in/
24 | [Oo]bj/
25 |
26 | # Visual Studio 2015 cache/options directory
27 | .vs/
28 | # Uncomment if you have tasks that create the project's static files in wwwroot
29 | #wwwroot/
30 |
31 | # MSTest test Results
32 | [Tt]est[Rr]esult*/
33 | [Bb]uild[Ll]og.*
34 |
35 | # NUNIT
36 | *.VisualState.xml
37 | TestResult.xml
38 |
39 | # Build Results of an ATL Project
40 | [Dd]ebugPS/
41 | [Rr]eleasePS/
42 | dlldata.c
43 |
44 | # DNX
45 | project.lock.json
46 | artifacts/
47 |
48 | *_i.c
49 | *_p.c
50 | *_i.h
51 | *.ilk
52 | *.meta
53 | *.obj
54 | *.pch
55 | *.pdb
56 | *.pgc
57 | *.pgd
58 | *.rsp
59 | *.sbr
60 | *.tlb
61 | *.tli
62 | *.tlh
63 | *.tmp
64 | *.tmp_proj
65 | *.log
66 | *.vspscc
67 | *.vssscc
68 | .builds
69 | *.pidb
70 | *.svclog
71 | *.scc
72 |
73 | # Chutzpah Test files
74 | _Chutzpah*
75 |
76 | # Visual C++ cache files
77 | ipch/
78 | *.aps
79 | *.ncb
80 | *.opendb
81 | *.opensdf
82 | *.sdf
83 | *.cachefile
84 | *.VC.db
85 |
86 | # Visual Studio profiler
87 | *.psess
88 | *.vsp
89 | *.vspx
90 | *.sap
91 |
92 | # TFS 2012 Local Workspace
93 | $tf/
94 |
95 | # Guidance Automation Toolkit
96 | *.gpState
97 |
98 | # ReSharper is a .NET coding add-in
99 | _ReSharper*/
100 | *.[Rr]e[Ss]harper
101 | *.DotSettings.user
102 |
103 | # JustCode is a .NET coding add-in
104 | .JustCode
105 |
106 | # TeamCity is a build add-in
107 | _TeamCity*
108 |
109 | # DotCover is a Code Coverage Tool
110 | *.dotCover
111 |
112 | # NCrunch
113 | _NCrunch_*
114 | .*crunch*.local.xml
115 | nCrunchTemp_*
116 |
117 | # MightyMoose
118 | *.mm.*
119 | AutoTest.Net/
120 |
121 | # Web workbench (sass)
122 | .sass-cache/
123 |
124 | # Installshield output folder
125 | [Ee]xpress/
126 |
127 | # DocProject is a documentation generator add-in
128 | DocProject/buildhelp/
129 | DocProject/Help/*.HxT
130 | DocProject/Help/*.HxC
131 | DocProject/Help/*.hhc
132 | DocProject/Help/*.hhk
133 | DocProject/Help/*.hhp
134 | DocProject/Help/Html2
135 | DocProject/Help/html
136 |
137 | # Click-Once directory
138 | publish/
139 |
140 | # Publish Web Output
141 | *.[Pp]ublish.xml
142 | *.azurePubxml
143 |
144 | # TODO: Un-comment the next line if you do not want to checkin
145 | # your web deploy settings because they may include unencrypted
146 | # passwords
147 | #*.pubxml
148 | *.publishproj
149 |
150 | # NuGet Packages
151 | *.nupkg
152 | # The packages folder can be ignored because of Package Restore
153 | **/packages/*
154 | # except build/, which is used as an MSBuild target.
155 | !**/packages/build/
156 | # Uncomment if necessary however generally it will be regenerated when needed
157 | #!**/packages/repositories.config
158 | # NuGet v3's project.json files produces more ignoreable files
159 | *.nuget.props
160 | *.nuget.targets
161 |
162 | # Microsoft Azure Build Output
163 | csx/
164 | *.build.csdef
165 |
166 | # Microsoft Azure Emulator
167 | ecf/
168 | rcf/
169 |
170 | # Windows Store app package directory
171 | AppPackages/
172 | BundleArtifacts/
173 |
174 | # Visual Studio cache files
175 | # files ending in .cache can be ignored
176 | *.[Cc]ache
177 | # but keep track of directories ending in .cache
178 | !*.[Cc]ache/
179 |
180 | # Others
181 | ClientBin/
182 | [Ss]tyle[Cc]op.*
183 | ~$*
184 | *~
185 | *.dbmdl
186 | *.dbproj.schemaview
187 | *.pfx
188 | *.publishsettings
189 | node_modules/
190 | orleans.codegen.cs
191 |
192 | # RIA/Silverlight projects
193 | Generated_Code/
194 |
195 | # Backup & report files from converting an old project file
196 | # to a newer Visual Studio version. Backup files are not needed,
197 | # because we have git ;-)
198 | _UpgradeReport_Files/
199 | Backup*/
200 | UpgradeLog*.XML
201 | UpgradeLog*.htm
202 |
203 | # SQL Server files
204 | *.mdf
205 | *.ldf
206 |
207 | # Business Intelligence projects
208 | *.rdl.data
209 | *.bim.layout
210 | *.bim_*.settings
211 |
212 | # Microsoft Fakes
213 | FakesAssemblies/
214 |
215 | # GhostDoc plugin setting file
216 | *.GhostDoc.xml
217 |
218 | # Node.js Tools for Visual Studio
219 | .ntvs_analysis.dat
220 |
221 | # Visual Studio 6 build log
222 | *.plg
223 |
224 | # Visual Studio 6 workspace options file
225 | *.opt
226 |
227 | # Visual Studio LightSwitch build output
228 | **/*.HTMLClient/GeneratedArtifacts
229 | **/*.DesktopClient/GeneratedArtifacts
230 | **/*.DesktopClient/ModelManifest.xml
231 | **/*.Server/GeneratedArtifacts
232 | **/*.Server/ModelManifest.xml
233 | _Pvt_Extensions
234 |
235 | # LightSwitch generated files
236 | GeneratedArtifacts/
237 | ModelManifest.xml
238 |
239 | # Paket dependency manager
240 | .paket/paket.exe
241 |
242 | # FAKE - F# Make
243 | .fake/
244 | .vs
245 | .idea
246 |
247 | # Verify test files
248 | *.received.txt
249 |
250 | .env
251 |
--------------------------------------------------------------------------------
/src/Senders/FluentEmail.MailPace/MailPaceSender.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.IO;
3 | using System.Linq;
4 | using System.Net.Http;
5 | using System.Net.Http.Headers;
6 | using System.Text;
7 | using System.Threading;
8 | using System.Threading.Tasks;
9 | using FluentEmail.Core;
10 | using FluentEmail.Core.Interfaces;
11 | using FluentEmail.Core.Models;
12 | using Newtonsoft.Json;
13 |
14 | namespace FluentEmail.MailPace;
15 |
16 | public class MailPaceSender : ISender, IDisposable
17 | {
18 | private readonly HttpClient _httpClient;
19 |
20 | public MailPaceSender(string serverToken)
21 | {
22 | _httpClient = new HttpClient();
23 | _httpClient.DefaultRequestHeaders.Add("MailPace-Server-Token", serverToken);
24 | _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
25 | }
26 |
27 | public SendResponse Send(IFluentEmail email, CancellationToken? token = null) =>
28 | SendAsync(email, token).GetAwaiter().GetResult();
29 |
30 | public async Task SendAsync(IFluentEmail email, CancellationToken? token = null)
31 | {
32 | var sendRequest = BuildSendRequestFor(email);
33 |
34 | var content = new StringContent(JsonConvert.SerializeObject(sendRequest), Encoding.UTF8, "application/json");
35 |
36 | var response = await _httpClient.PostAsync("https://app.mailpace.com/api/v1/send", content)
37 | .ConfigureAwait(false);
38 |
39 | var mailPaceResponse = await TryOrNull(async () => JsonConvert.DeserializeObject(
40 | await response.Content.ReadAsStringAsync())) ?? new MailPaceResponse();
41 |
42 | if (response.IsSuccessStatusCode)
43 | {
44 | return new SendResponse { MessageId = mailPaceResponse.Id };
45 | }
46 | else
47 | {
48 | var result = new SendResponse();
49 |
50 | if (!string.IsNullOrEmpty(mailPaceResponse.Error))
51 | {
52 | result.ErrorMessages.Add(mailPaceResponse.Error);
53 | }
54 |
55 | if (mailPaceResponse.Errors != null && mailPaceResponse.Errors.Count != 0)
56 | {
57 | result.ErrorMessages.AddRange(mailPaceResponse.Errors
58 | .Select(it => $"{it.Key}: {string.Join("; ", it.Value)}"));
59 | }
60 |
61 | if (!result.ErrorMessages.Any())
62 | {
63 | result.ErrorMessages.Add(response.ReasonPhrase ?? "An unknown error has occurred.");
64 | }
65 |
66 | return result;
67 | }
68 | }
69 |
70 | private static MailPaceSendRequest BuildSendRequestFor(IFluentEmail email)
71 | {
72 | var sendRequest = new MailPaceSendRequest
73 | {
74 | From = $"{email.Data.FromAddress.Name} <{email.Data.FromAddress.EmailAddress}>",
75 | To = string.Join(",", email.Data.ToAddresses.Select(it => !string.IsNullOrEmpty(it.Name) ? $"{it.Name} <{it.EmailAddress}>" : it.EmailAddress)),
76 | Subject = email.Data.Subject
77 | };
78 |
79 | if (email.Data.CcAddresses.Any())
80 | {
81 | sendRequest.Cc = string.Join(",", email.Data.CcAddresses.Select(it => !string.IsNullOrEmpty(it.Name) ? $"{it.Name} <{it.EmailAddress}>" : it.EmailAddress));
82 | }
83 |
84 | if (email.Data.BccAddresses.Any())
85 | {
86 | sendRequest.Bcc = string.Join(",", email.Data.BccAddresses.Select(it => !string.IsNullOrEmpty(it.Name) ? $"{it.Name} <{it.EmailAddress}>" : it.EmailAddress));
87 | }
88 |
89 | if (email.Data.ReplyToAddresses.Any())
90 | {
91 | sendRequest.ReplyTo = string.Join(",", email.Data.ReplyToAddresses.Select(it => !string.IsNullOrEmpty(it.Name) ? $"{it.Name} <{it.EmailAddress}>" : it.EmailAddress));
92 | }
93 |
94 | if (email.Data.IsHtml)
95 | {
96 | sendRequest.HtmlBody = email.Data.Body;
97 | if (!string.IsNullOrEmpty(email.Data.PlaintextAlternativeBody))
98 | {
99 | sendRequest.TextBody = email.Data.PlaintextAlternativeBody;
100 | }
101 | }
102 | else
103 | {
104 | sendRequest.TextBody = email.Data.Body;
105 | }
106 |
107 | if (email.Data.Tags.Any())
108 | {
109 | sendRequest.Tags.AddRange(email.Data.Tags);
110 | }
111 |
112 | if (email.Data.Attachments.Any())
113 | {
114 | sendRequest.Attachments.AddRange(
115 | email.Data.Attachments.Select(it => new MailPaceAttachment
116 | {
117 | Name = it.Filename,
118 | Content = it.Data.ConvertToBase64(),
119 | ContentType = it.ContentType ?? Path.GetExtension(it.Filename), // jpeg, jpg, png, gif, txt, pdf, docx, xlsx, pptx, csv, att, ics, ical, html, zip
120 | Cid = it.IsInline ? it.ContentId : null
121 | }));
122 | }
123 |
124 | return sendRequest;
125 | }
126 |
127 | private async Task TryOrNull(Func> method)
128 | {
129 | try
130 | {
131 | return await method();
132 | }
133 | catch
134 | {
135 | return default;
136 | }
137 | }
138 |
139 | public void Dispose()
140 | {
141 | _httpClient.Dispose();
142 | }
143 | }
--------------------------------------------------------------------------------
/src/Senders/FluentEmail.Postmark/PostmarkSender.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Threading;
5 | using System.Threading.Tasks;
6 | using FluentEmail.Core;
7 | using FluentEmail.Core.Interfaces;
8 | using FluentEmail.Core.Models;
9 | using PostmarkDotNet;
10 |
11 | namespace FluentEmail.Postmark
12 | {
13 | ///
14 | /// A FluentEmail ISender implementation that uses postmark to send emails.
15 | ///
16 | public class PostmarkSender : ISender
17 | {
18 | private readonly PostmarkSenderOptions options;
19 |
20 | ///
21 | /// Creates a new instance of the PostmarkSender class.
22 | ///
23 | /// The serverToken to use to authenticate at the Postmark API.
24 | public PostmarkSender(string serverToken) :
25 | this(new PostmarkSenderOptions(serverToken ?? throw new ArgumentNullException(nameof(serverToken))))
26 | {
27 | }
28 |
29 | ///
30 | /// Creates a new instance of the PostmarkSender class.
31 | ///
32 | /// The options to configure the behaviour of this sender.
33 | public PostmarkSender(PostmarkSenderOptions options)
34 | {
35 | this.options = options ?? throw new ArgumentNullException(nameof(options));
36 | if (string.IsNullOrWhiteSpace(options.ServerToken))
37 | throw new ArgumentException("The ServerToken property of the given options is null or whitespace but it is required to be set to a valid value.", nameof(options.ServerToken));
38 | }
39 |
40 | ///
41 | /// Sends the email using the Postmark API. The implementation is async internally, this is a blocking wrapper.
42 | ///
43 | /// /// Returns a SendResponse instance that contains the Postmark ErrorCode as only ErrorMessage if the send was not successfull.
44 | public SendResponse Send(IFluentEmail email, CancellationToken? token = null)
45 | {
46 | // see https://stackoverflow.com/a/17284612/1200847
47 | // instead of .Result to not get an AggregateException
48 | return SendAsync(email, token).GetAwaiter().GetResult();
49 | }
50 |
51 | ///
52 | /// Sends the email asynchronously using the Postmark API.
53 | ///
54 | /// Returns a SendResponse instance that contains the Postmark ErrorCode as only ErrorMessage if the send was not successfull.
55 | public async Task SendAsync(IFluentEmail email, CancellationToken? token = null)
56 | {
57 | _ = email ?? throw new ArgumentNullException(nameof(email));
58 | var client = new PostmarkClient(options.ServerToken);
59 | var msg = CreatePostmarkMessage(email);
60 | var resp = await client.SendMessageAsync(msg).ConfigureAwait(false);
61 | return CreateSendResponse(resp);
62 | }
63 |
64 | private PostmarkMessage CreatePostmarkMessage(IFluentEmail email)
65 | {
66 | // see also https://postmarkapp.com/developer/api/email-api
67 |
68 | var msg = new PostmarkMessage
69 | {
70 | From = string.IsNullOrEmpty(email.Data.FromAddress.Name) ?
71 | email.Data.FromAddress.EmailAddress :
72 | $"{email.Data.FromAddress.Name} {email.Data.FromAddress.EmailAddress}",
73 |
74 | To = email.Data.ToAddresses.ToPmAddressString(),
75 | Cc = email.Data.CcAddresses.ToPmAddressString(),
76 | Bcc = email.Data.BccAddresses.ToPmAddressString(),
77 | ReplyTo = email.Data.ReplyToAddresses.ToPmAddressString(),
78 |
79 | Subject = email.Data.Subject
80 | };
81 |
82 | var pmHeaderEnum = (email.Data.Headers ?? Enumerable.Empty>())
83 | .Select(kvp => new PostmarkDotNet.Model.MailHeader(kvp.Key, kvp.Value));
84 | pmHeaderEnum = pmHeaderEnum.Concat(email.Data.Priority.GetPmHeaders()); // add headers representing prio
85 | foreach (var pmh in pmHeaderEnum)
86 | {
87 | msg.Headers.Add(pmh);
88 | }
89 |
90 | if (email.Data.IsHtml)
91 | {
92 | msg.HtmlBody = email.Data.Body;
93 | msg.TextBody = email.Data.PlaintextAlternativeBody;
94 | }
95 | else
96 | {
97 | msg.TextBody = email.Data.Body;
98 | }
99 |
100 | foreach (var attachment in email.Data.Attachments ?? Enumerable.Empty())
101 | {
102 | msg.AddAttachment(attachment.Data, attachment.Filename, attachment.ContentType, attachment.ContentId);
103 | }
104 |
105 | msg.TrackOpens = options.TrackOpens;
106 | msg.TrackLinks = options.TrackLinks;
107 | if (options.Tag != null)
108 | msg.Tag = options.Tag;
109 | if (options.Metadata != null)
110 | msg.Metadata = options.Metadata;
111 |
112 | return msg;
113 | }
114 |
115 | private static SendResponse CreateSendResponse(PostmarkResponse value)
116 | {
117 | var ret = new SendResponse();
118 | ret.MessageId = value.MessageID.ToString();
119 | if (value.Status == PostmarkStatus.Success) return ret;
120 | ret.ErrorMessages.Add(value.ErrorCode.ToString(System.Globalization.CultureInfo.InvariantCulture));
121 | return ret;
122 | }
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/src/Senders/FluentEmail.Mailtrap/MailtrapSender.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Net;
5 | using System.Net.Http;
6 | using System.Net.Http.Headers;
7 | using System.Net.Mail;
8 | using System.Threading;
9 | using System.Threading.Tasks;
10 | using FluentEmail.Core;
11 | using FluentEmail.Core.Models;
12 | using FluentEmail.Mailtrap.HttpHelpers;
13 | using FluentEmail.Smtp;
14 |
15 | namespace FluentEmail.Mailtrap
16 | {
17 | ///
18 | /// Send emails to a Mailtrap.io inbox
19 | ///
20 | public class MailtrapSender : IMailtrapSender, IDisposable
21 | {
22 | private readonly SmtpClient _smtpClient;
23 | private static readonly int[] ValidPorts = {25,587, 2525};
24 | private readonly string _apiKey;
25 | private readonly string _apiHost;
26 |
27 | ///
28 | /// Creates a sender that uses the given Mailtrap credentials, but does not dispose it.
29 | ///
30 | /// Username of your mailtrap.io SMTP inbox
31 | /// Password of your mailtrap.io SMTP inbox
32 | /// Host address for the Mailtrap.io SMTP inbox
33 | /// Port for the Mailtrap.io SMTP server. Accepted values are 25, 465 or 2525.
34 | public MailtrapSender(string userName, string password, string host = "smtp.mailtrap.io", int? port = null, string apiHost = "https://send.api.mailtrap.io/api/send")
35 | {
36 | if (string.IsNullOrWhiteSpace(userName))
37 | throw new ArgumentException("Mailtrap UserName needs to be supplied", nameof(userName));
38 |
39 | if (string.IsNullOrWhiteSpace(password))
40 | throw new ArgumentException("Mailtrap Password needs to be supplied", nameof(password));
41 |
42 | if (port.HasValue && !ValidPorts.Contains(port.Value))
43 | throw new ArgumentException("Mailtrap Port needs to be either 25, 465 or 2525", nameof(port));
44 | _apiKey = password;
45 | _apiHost = apiHost;
46 | _smtpClient = new SmtpClient(host, port.GetValueOrDefault(587))
47 | {
48 | Credentials = new NetworkCredential(userName, password),
49 | EnableSsl = true
50 | };
51 | }
52 |
53 | public void Dispose() => _smtpClient?.Dispose();
54 |
55 | public SendResponse Send(IFluentEmail email, CancellationToken? token = null)
56 | {
57 | var smtpSender = new SmtpSender(_smtpClient);
58 | return smtpSender.Send(email, token);
59 | }
60 |
61 | public Task SendAsync(IFluentEmail email, CancellationToken? token = null)
62 | {
63 | var smtpSender = new SmtpSender(_smtpClient);
64 | return smtpSender.SendAsync(email, token);
65 | }
66 |
67 | public async Task SendWithTemplateAsync(IFluentEmail email, string templateName, object templateData, CancellationToken? token = null)
68 | {
69 | token?.ThrowIfCancellationRequested();
70 | using (var httpClient = new HttpClient { BaseAddress = new Uri(_apiHost) })
71 | {
72 | httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
73 | httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
74 | var jsonContent = HttpClientHelpers.GetJsonBody(BuildMailtrapParameters(email, templateName, templateData));
75 | var response = await httpClient.Post(_apiHost, jsonContent);
76 | var result = new SendResponse { MessageId = response.Data?.Id };
77 | if (!response.Success)
78 | {
79 | result.ErrorMessages.AddRange(response.Errors.Select(x => x.ErrorMessage));
80 | return result;
81 | }
82 | return result;
83 | }
84 |
85 | }
86 |
87 | private static Dictionary BuildMailtrapParameters(IFluentEmail email, string templateName, object templateData)
88 | {
89 | var parameters = new Dictionary();
90 | parameters["from"] = new Dictionary{
91 | {"email", email.Data.FromAddress.EmailAddress},
92 | {"name", email.Data.FromAddress.Name}
93 | };
94 | var to= new List>();
95 | email.Data.ToAddresses.ForEach(x =>
96 | {
97 | to.Add(new Dictionary { { "email", x.EmailAddress } });
98 | });
99 | parameters["to"] = to;
100 | var cc = new List>();
101 | email.Data.CcAddresses.ForEach(x =>
102 | {
103 | cc.Add(new Dictionary { { "email", x.EmailAddress } });
104 | });
105 | if (cc.Any())
106 | {
107 | parameters["cc"] = to;
108 | }
109 | var bcc = new List>();
110 | email.Data.BccAddresses.ForEach(x =>
111 | {
112 | bcc.Add(new Dictionary { { "email", x.EmailAddress } });
113 | });
114 | if (cc.Any())
115 | {
116 | parameters["bcc"] = bcc;
117 | }
118 | parameters["template_uuid"] = templateName;
119 | var templateVariables = templateData.GetType().GetProperties()
120 | .ToDictionary(
121 | prop => prop.Name,
122 | prop => prop.GetValue(templateData).ToString()
123 | );
124 | parameters["template_variables"] = templateVariables;
125 | return parameters;
126 | }
127 | }
128 | }
129 |
--------------------------------------------------------------------------------
/test/FluentEmail.ThirdParty.Tests/MailgunSenderTests.cs:
--------------------------------------------------------------------------------
1 | using FluentEmail.Core;
2 | using FluentEmail.Core.Tests;
3 | using FluentEmail.Mailgun;
4 | using Newtonsoft.Json;
5 |
6 | namespace FluentEmail.ThirdParty.Tests;
7 |
8 | public class MailgunSenderTests
9 | {
10 | private readonly string _toEmail = Credentials.Mailgun.ToEmail ?? Credentials.ToEmail;
11 | private readonly string _fromEmail = Credentials.Mailgun.FromEmail ?? Credentials.FromEmail;
12 | private readonly string _apiKey = Credentials.Mailgun.ApiKey;
13 | private readonly string _domain = Credentials.Mailgun.Domain;
14 | private const string Subject = "Attachment Tests";
15 | private const string Body = "This email is testing the attachment functionality of MailGun.";
16 |
17 | private ISender Sender { get; }
18 |
19 | public MailgunSenderTests()
20 | {
21 | if (!string.IsNullOrEmpty(_apiKey)) Sender = new MailgunSender(_domain, _apiKey);
22 | }
23 |
24 | [Fact]
25 | public async Task CanSendEmail()
26 | {
27 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
28 |
29 | var email = Email
30 | .From(_fromEmail)
31 | .To(_toEmail)
32 | .Subject(Subject)
33 | .Body(Body);
34 |
35 | email.Sender = Sender;
36 | var response = await email.SendAsync();
37 |
38 | (response.Successful).Should().BeTrue();
39 | }
40 |
41 | [Fact]
42 | public async Task GetMessageIdInResponse()
43 | {
44 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
45 |
46 | var email = Email
47 | .From(_fromEmail)
48 | .To(_toEmail)
49 | .Subject(Subject)
50 | .Body(Body);
51 |
52 | email.Sender = Sender;
53 | var response = await email.SendAsync();
54 |
55 | (response.Successful).Should().BeTrue();
56 | (response.MessageId).Should().NotBeEmpty();
57 | }
58 |
59 | [Fact]
60 | public async Task CanSendEmailWithTag()
61 | {
62 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
63 |
64 | var email = Email
65 | .From(_fromEmail)
66 | .To(_toEmail)
67 | .Subject(Subject)
68 | .Body(Body)
69 | .Tag("test");
70 |
71 | email.Sender = Sender;
72 | var response = await email.SendAsync();
73 |
74 | (response.Successful).Should().BeTrue();
75 | }
76 |
77 | [Fact]
78 | public async Task CanSendEmailWithVariables()
79 | {
80 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
81 |
82 | var email = Email
83 | .From(_fromEmail)
84 | .To(_toEmail)
85 | .Subject(Subject)
86 | .Body(Body)
87 | .Header("X-Mailgun-Variables", JsonConvert.SerializeObject(new Variable { Var1 = "Test"}));
88 |
89 | email.Sender = Sender;
90 | var response = await email.SendAsync();
91 |
92 | (response.Successful).Should().BeTrue();
93 | }
94 |
95 | [Fact]
96 | public async Task CanSendEmailWithAttachments()
97 | {
98 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
99 |
100 | var stream = new MemoryStream();
101 | var sw = new StreamWriter(stream);
102 | await sw.WriteLineAsync("Hey this is some text in an attachment");
103 | await sw.FlushAsync(TestContext.Current.CancellationToken);
104 | stream.Seek(0, SeekOrigin.Begin);
105 |
106 | var attachment = new Attachment
107 | {
108 | Data = stream,
109 | ContentType = "text/plain",
110 | Filename = "mailgunTest.txt"
111 | };
112 |
113 | var email = Email
114 | .From(_fromEmail)
115 | .To(_toEmail)
116 | .Subject(Subject)
117 | .Body(Body)
118 | .Attach(attachment);
119 |
120 | email.Sender = Sender;
121 | var response = await email.SendAsync();
122 |
123 | (response.Successful).Should().BeTrue();
124 | }
125 |
126 | [Fact]
127 | public async Task CanSendEmailWithInlineImages()
128 | {
129 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
130 |
131 | await using var stream = File.OpenRead($"{Path.Combine(Directory.GetCurrentDirectory(), "logotest.png")}");
132 | var attachment = new Attachment
133 | {
134 | IsInline = true,
135 | Data = stream,
136 | ContentType = "image/png",
137 | Filename = "logotest.png"
138 | };
139 |
140 | var email = Email
141 | .From(_fromEmail)
142 | .To(_toEmail)
143 | .Subject(Subject)
144 | .Body("Inline image here: " +
145 | "You should see an image without an attachment, or without a download prompt, depending on the email client.
", true)
146 | .Attach(attachment);
147 |
148 | email.Sender = Sender;
149 | var response = await email.SendAsync();
150 |
151 | (response.Successful).Should().BeTrue();
152 | }
153 |
154 | [Fact]
155 | public async Task CanSendEmailWithTemplate()
156 | {
157 | Assert.SkipWhen(string.IsNullOrEmpty(_apiKey), "No Mailgun Credentials");
158 | Assert.SkipWhen(string.IsNullOrEmpty(Credentials.Mailgun.Template), "No Mailgun Template");
159 |
160 | var email = Email
161 | .From(_fromEmail)
162 | .To(_toEmail)
163 | .Subject(Subject);
164 |
165 | email.Sender = Sender;
166 | var response = await email.SendWithTemplateAsync("test-template", new { var1 = "Test" });
167 |
168 | (response.Successful).Should().BeTrue();
169 | }
170 |
171 | private class Variable
172 | {
173 | // ReSharper disable once UnusedAutoPropertyAccessor.Local
174 | public string Var1 { get; set; }
175 | }
176 | }
--------------------------------------------------------------------------------
/src/Renderers/FluentEmail.Bootstrap/FluentEmailFluidBuilderExtensions.cs:
--------------------------------------------------------------------------------
1 | using System.Globalization;
2 | using System.Reflection;
3 | using UnDotNet.BootstrapEmail;
4 |
5 | // ReSharper disable once CheckNamespace
6 | namespace FluentEmail.Core;
7 |
8 | public static class FluentEmailBootstrap
9 | {
10 | ///
11 | /// Compiles the template from the renderer through UnDotNet.BootstrapEmail
12 | ///
13 | /// The IFluentEmail object
14 | /// True if you want to set the plain text alternative automatically using UnDotNet.HtmlToText (Optional)
15 | /// Instance of the Email class
16 | // ReSharper disable once MemberCanBePrivate.Global
17 | public static IFluentEmail CompileBootstrap(this IFluentEmail email, bool plainText = true)
18 | {
19 | var compiler = new BootstrapCompiler(email.Data.Body);
20 | var result = compiler.Multipart();
21 | email.Data.Body = result.Html;
22 | email.Data.IsHtml = true;
23 | if (plainText)
24 | {
25 | email.PlaintextAlternativeBody(result.Text);
26 | }
27 |
28 | return email;
29 | }
30 |
31 | ///
32 | /// Adds Bootstrap body to the email
33 | ///
34 | /// The IFluentEmail object
35 | /// The body
36 | /// True if Body is HTML, false for plain text (Optional)
37 | /// Instance of the Email class
38 | public static IFluentEmail UsingBootstrapBody(this IFluentEmail email, string body, bool isHtml = true)
39 | {
40 | email.Body(body, isHtml);
41 | email.CompileBootstrap(isHtml);
42 | return email;
43 | }
44 |
45 | ///
46 | /// Adds Bootstrap template to the email
47 | ///
48 | ///
49 | /// The IFluentEmail object
50 | /// The template
51 | /// Model for the template
52 | /// True if Body is HTML, false for plain text (Optional)
53 | /// Instance of the Email class
54 | public static IFluentEmail UsingBootstrapTemplate(this IFluentEmail email, string template, T model,
55 | bool isHtml = true)
56 | {
57 | email.UsingTemplate(template, model, isHtml);
58 | email.CompileBootstrap(isHtml);
59 | return email;
60 | }
61 |
62 | ///
63 | /// Adds Bootstrap template to email from embedded resource
64 | ///
65 | ///
66 | /// The IFluentEmail object
67 | /// Path the the embedded resource eg [YourAssembly].[YourResourceFolder].[YourFilename.txt]
68 | /// Model for the template
69 | /// The assembly your resource is in. Defaults to calling assembly.
70 | /// True if Body is HTML (default), false for plain text
71 | ///
72 | public static IFluentEmail UsingBootstrapTemplateFromEmbedded(this IFluentEmail email, string path, T model,
73 | Assembly assembly, bool isHtml = true)
74 | {
75 | email.UsingTemplateFromEmbedded(path, model, assembly, isHtml);
76 | email.CompileBootstrap(isHtml);
77 | return email;
78 | }
79 |
80 | ///
81 | /// Adds Bootstrap template to email from previously configured default embedded resource
82 | ///
83 | ///
84 | /// The IFluentEmail object
85 | /// Path the the embedded resource eg [YourResourceFolder].[YourFilename.txt]. Will be appended to configured root path
86 | /// Model for the template
87 | /// True if Body is HTML (default), false for plain text
88 | ///
89 | public static IFluentEmail UsingBootstrapTemplateFromEmbedded(this IFluentEmail email, string path, T model,
90 | bool isHtml = true)
91 | {
92 | email.UsingTemplateFromEmbedded(path, model, isHtml);
93 | email.CompileBootstrap(isHtml);
94 | return email;
95 | }
96 |
97 | ///
98 | /// Adds Bootstrap template to email from embedded resource
99 | ///
100 | ///
101 | /// The IFluentEmail object
102 | /// The path to the file to load
103 | /// Model for the template
104 | /// True if Body is HTML (default), false for plain text
105 | ///
106 | public static IFluentEmail UsingBootstrapTemplateFromFile(this IFluentEmail email, string filename, T model,
107 | bool isHtml = true)
108 | {
109 | email.UsingTemplateFromFile(filename, model, isHtml);
110 | email.CompileBootstrap(isHtml);
111 | return email;
112 | }
113 |
114 | ///
115 | /// Adds Bootstrap template to email from previously configured default embedded resource
116 | ///
117 | ///
118 | /// The IFluentEmail object
119 | /// The path to the file to load
120 | /// Model for the template
121 | /// The culture of the template (Default is the current culture)
122 | /// True if Body is HTML (default), false for plain text
123 | ///
124 | public static IFluentEmail UsingBootstrapCultureTemplateFromFile(this IFluentEmail email, string filename,
125 | T model, CultureInfo culture, bool isHtml = true)
126 | {
127 | email.UsingCultureTemplateFromFile(filename, model, culture, isHtml);
128 | email.CompileBootstrap(isHtml);
129 | return email;
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/src/Senders/FluentEmail.Mailgun/MailgunSender.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Net.Http;
5 | using System.Net.Http.Headers;
6 | using System.Text;
7 | using System.Threading;
8 | using System.Threading.Tasks;
9 | using FluentEmail.Core;
10 | using FluentEmail.Core.Interfaces;
11 | using FluentEmail.Core.Models;
12 | using FluentEmail.Mailgun.HttpHelpers;
13 | using Newtonsoft.Json;
14 |
15 | namespace FluentEmail.Mailgun
16 | {
17 | public class MailgunSender : IMailgunSender
18 | {
19 | private readonly string _apiKey;
20 | private readonly string _domainName;
21 | private HttpClient _httpClient;
22 |
23 | public MailgunSender(string domainName, string apiKey, MailGunRegion mailGunRegion = MailGunRegion.USA)
24 | {
25 | _domainName = domainName;
26 | _apiKey = apiKey;
27 | string url = string.Empty;
28 | switch(mailGunRegion)
29 | {
30 | case MailGunRegion.USA:
31 | url = $"https://api.mailgun.net/v3/{_domainName}/";
32 | break;
33 | case MailGunRegion.EU:
34 | url = $"https://api.eu.mailgun.net/v3/{_domainName}/";
35 | break;
36 |
37 | default:
38 | throw new ArgumentException($"'{mailGunRegion}' is not a valid value for {nameof(mailGunRegion)}");
39 | }
40 | _httpClient = new HttpClient
41 | {
42 | BaseAddress = new Uri(url)
43 | };
44 |
45 | _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"api:{_apiKey}")));
46 | }
47 |
48 | public SendResponse Send(IFluentEmail email, CancellationToken? token = null)
49 | {
50 | return SendAsync(email, token).GetAwaiter().GetResult();
51 | }
52 |
53 | public async Task SendAsync(IFluentEmail email, CancellationToken? token = null)
54 | {
55 | var parameters = BuildMailgunParameters(email);
56 |
57 | parameters.Add(new KeyValuePair(email.Data.IsHtml ? "html" : "text", email.Data.Body));
58 |
59 | if (!string.IsNullOrEmpty(email.Data.PlaintextAlternativeBody))
60 | {
61 | parameters.Add(new KeyValuePair("text", email.Data.PlaintextAlternativeBody));
62 | }
63 |
64 | var files = BuildMailgunFiles(email);
65 |
66 | return await SendAsync(parameters, files, token);
67 | }
68 |
69 | private async Task SendAsync(List> parameters, List files, CancellationToken? token = null)
70 | {
71 | token?.ThrowIfCancellationRequested();
72 |
73 | var response = await _httpClient.PostMultipart("messages", parameters, files)
74 | .ConfigureAwait(false);
75 |
76 | var result = new SendResponse {MessageId = response.Data?.Id};
77 | if (!response.Success)
78 | {
79 | result.ErrorMessages.AddRange(response.Errors.Select(x => x.ErrorMessage));
80 | return result;
81 | }
82 |
83 | return result;
84 | }
85 |
86 | private static List BuildMailgunFiles(IFluentEmail email)
87 | {
88 | var files = new List();
89 | email.Data.Attachments.ForEach(x =>
90 | {
91 | string param;
92 |
93 | if (x.IsInline)
94 | param = "inline";
95 | else
96 | param = "attachment";
97 |
98 | files.Add(new HttpFile
99 | {
100 | ParameterName = param,
101 | Data = x.Data,
102 | Filename = x.Filename,
103 | ContentType = x.ContentType
104 | });
105 | });
106 | return files;
107 | }
108 |
109 | private static List> BuildMailgunParameters(IFluentEmail email)
110 | {
111 | var parameters = new List>();
112 |
113 | parameters.Add(new KeyValuePair("from",
114 | $"{email.Data.FromAddress.Name} <{email.Data.FromAddress.EmailAddress}>"));
115 |
116 | email.Data.ToAddresses.ForEach(x =>
117 | {
118 | parameters.Add(new KeyValuePair("to", $"{x.Name} <{x.EmailAddress}>"));
119 | });
120 | email.Data.CcAddresses.ForEach(x =>
121 | {
122 | parameters.Add(new KeyValuePair("cc", $"{x.Name} <{x.EmailAddress}>"));
123 | });
124 | email.Data.BccAddresses.ForEach(x =>
125 | {
126 | parameters.Add(new KeyValuePair("bcc", $"{x.Name} <{x.EmailAddress}>"));
127 | });
128 | email.Data.ReplyToAddresses.ForEach(x =>
129 | {
130 | parameters.Add(new KeyValuePair("h:Reply-To", $"{x.Name} <{x.EmailAddress}>"));
131 | });
132 | parameters.Add(new KeyValuePair("subject", email.Data.Subject));
133 |
134 | email.Data.Tags.ForEach(x => { parameters.Add(new KeyValuePair("o:tag", x)); });
135 |
136 | foreach (var emailHeader in email.Data.Headers)
137 | {
138 | var key = emailHeader.Key;
139 | if (!key.StartsWith("h:"))
140 | {
141 | key = "h:" + emailHeader.Key;
142 | }
143 |
144 | parameters.Add(new KeyValuePair(key, emailHeader.Value));
145 | }
146 |
147 | return parameters;
148 | }
149 |
150 | public async Task SendWithTemplateAsync(IFluentEmail email, string templateName, object templateData,
151 | CancellationToken? token = null)
152 | {
153 | var parameters = BuildMailgunParameters(email);
154 | var files = BuildMailgunFiles(email);
155 |
156 | parameters.Add(new KeyValuePair("template", templateName));
157 | parameters.Add(new KeyValuePair("h:X-Mailgun-Variables", JsonConvert.SerializeObject(templateData)));
158 |
159 | return await SendAsync(parameters, files, token);
160 | }
161 | }
162 | }
163 |
--------------------------------------------------------------------------------
/src/Senders/FluentEmail.Graph/GraphSender.cs:
--------------------------------------------------------------------------------
1 | using FluentEmail.Core;
2 | using FluentEmail.Core.Interfaces;
3 | using FluentEmail.Core.Models;
4 | using Microsoft.Graph;
5 | using Microsoft.Graph.Auth;
6 | using Microsoft.Identity.Client;
7 | using System;
8 | using System.Collections.Generic;
9 | using System.IO;
10 | using System.Threading;
11 | using System.Threading.Tasks;
12 |
13 | namespace FluentEmail.Graph
14 | {
15 | public class GraphSender : ISender
16 | {
17 | private readonly string _appId;
18 | private readonly string _tenantId;
19 | private readonly string _graphSecret;
20 | private bool _saveSent;
21 |
22 | private ClientCredentialProvider _authProvider;
23 | private GraphServiceClient _graphClient;
24 | private IConfidentialClientApplication _clientApp;
25 |
26 | public GraphSender(
27 | string GraphEmailAppId,
28 | string GraphEmailTenantId,
29 | string GraphEmailSecret,
30 | bool SaveSentItems)
31 | {
32 | _appId = GraphEmailAppId;
33 | _tenantId = GraphEmailTenantId;
34 | _graphSecret = GraphEmailSecret;
35 | _saveSent = SaveSentItems;
36 |
37 | _clientApp = ConfidentialClientApplicationBuilder
38 | .Create(_appId)
39 | .WithTenantId(_tenantId)
40 | .WithClientSecret(_graphSecret)
41 | .Build();
42 |
43 | _authProvider = new ClientCredentialProvider(_clientApp);
44 |
45 | _graphClient = new GraphServiceClient(_authProvider);
46 | }
47 |
48 | public SendResponse Send(IFluentEmail email, CancellationToken? token = null)
49 | {
50 | return SendAsync(email, token).GetAwaiter().GetResult();
51 | }
52 |
53 | public async Task SendAsync(IFluentEmail email, CancellationToken? token = null)
54 | {
55 | var message = new Message
56 | {
57 | Subject = email.Data.Subject,
58 | Body = new ItemBody
59 | {
60 | Content = email.Data.Body,
61 | ContentType = email.Data.IsHtml ? BodyType.Html : BodyType.Text
62 | },
63 | From = new Recipient
64 | {
65 | EmailAddress = new EmailAddress
66 | {
67 | Address = email.Data.FromAddress.EmailAddress,
68 | Name = email.Data.FromAddress.Name
69 | }
70 | }
71 | };
72 |
73 | if(email.Data.ToAddresses != null && email.Data.ToAddresses.Count > 0)
74 | {
75 | var toRecipients = new List();
76 |
77 | email.Data.ToAddresses.ForEach(r => toRecipients.Add(new Recipient
78 | {
79 | EmailAddress = new EmailAddress
80 | {
81 | Address = r.EmailAddress.ToString(),
82 | Name = r.Name
83 | }
84 | }));
85 |
86 | message.ToRecipients = toRecipients;
87 | }
88 |
89 | if(email.Data.BccAddresses != null && email.Data.BccAddresses.Count > 0)
90 | {
91 | var bccRecipients = new List();
92 |
93 | email.Data.BccAddresses.ForEach(r => bccRecipients.Add(new Recipient
94 | {
95 | EmailAddress = new EmailAddress
96 | {
97 | Address = r.EmailAddress.ToString(),
98 | Name = r.Name
99 | }
100 | }));
101 |
102 | message.BccRecipients = bccRecipients;
103 | }
104 |
105 | if (email.Data.CcAddresses != null && email.Data.CcAddresses.Count > 0)
106 | {
107 | var ccRecipients = new List();
108 |
109 | email.Data.CcAddresses.ForEach(r => ccRecipients.Add(new Recipient
110 | {
111 | EmailAddress = new EmailAddress
112 | {
113 | Address = r.EmailAddress.ToString(),
114 | Name = r.Name
115 | }
116 | }));
117 |
118 | message.CcRecipients = ccRecipients;
119 | }
120 |
121 | if(email.Data.Attachments != null && email.Data.Attachments.Count > 0)
122 | {
123 | message.Attachments = new MessageAttachmentsCollectionPage();
124 |
125 | email.Data.Attachments.ForEach(a =>
126 | {
127 | var attachment = new FileAttachment
128 | {
129 | Name = a.Filename,
130 | ContentType = a.ContentType,
131 | ContentBytes = GetAttachmentBytes(a.Data)
132 | };
133 |
134 | message.Attachments.Add(attachment);
135 | });
136 | }
137 |
138 | switch(email.Data.Priority)
139 | {
140 | case Priority.High:
141 | message.Importance = Importance.High;
142 | break;
143 | case Priority.Normal:
144 | message.Importance = Importance.Normal;
145 | break;
146 | case Priority.Low:
147 | message.Importance = Importance.Low;
148 | break;
149 | default:
150 | message.Importance = Importance.Normal;
151 | break;
152 | }
153 |
154 | try
155 | {
156 | await _graphClient.Users[email.Data.FromAddress.EmailAddress]
157 | .SendMail(message, _saveSent)
158 | .Request()
159 | .PostAsync();
160 |
161 | return new SendResponse
162 | {
163 | MessageId = message.Id
164 | };
165 | }
166 | catch (Exception ex)
167 | {
168 | return new SendResponse
169 | {
170 | ErrorMessages = new List { ex.Message }
171 | };
172 | }
173 | }
174 |
175 | private static byte[] GetAttachmentBytes(Stream stream)
176 | {
177 | using(MemoryStream m = new MemoryStream())
178 | {
179 | stream.CopyTo(m);
180 | return m.ToArray();
181 | }
182 | }
183 | }
184 | }
185 |
--------------------------------------------------------------------------------