SMTP + better readme

Author: rafiki270

Package.resolved

@@ -11,13 +11,15 @@ let package = Package(
         .package(url: "https://github.com/vapor/vapor.git", from: "3.0.0-rc.2"),
         .package(url: "https://github.com/twof/VaporMailgunService.git", from: "0.4.0"),
         .package(url: "https://github.com/vapor-community/sendgrid-provider.git", from: "3.0.1"),
+        .package(url: "https://github.com/IBM-Swift/Swift-SMTP.git", from: "3.0.0"),
         .package(url: "https://github.com/LiveUI/VaporTestTools.git", .branch("master"))
     ],
     targets: [
         .target(name: "MailCore", dependencies: [
             "Vapor",
             "Mailgun",
-            "SendGrid"
+            "SendGrid",
+            "SwiftSMTP"
             ]
         ),
         .target(name: "MailCoreTestTools", dependencies: [

Package.swift

@@ -16,7 +16,7 @@ Mailing wrapper for multiple mailing services like MailGun, SendGrig or SMTP
 
 - [x] MailGun
 - [x] SendGrid
-- [ ] SMTP
+- [x] SMTP
 
 ## Install
 
@@ -26,24 +26,64 @@ Just add following line package to your `Package.swift` file.
 .package(url: "https://github.com/LiveUI/MailCore.git", .branch("master"))
 ```
 
-## Use
+## Usage
 
 Usage is really simple. First register the service in your apps `configure` method:
 
+#### Mailgun
+
 ```swift
-// Mailgun
 let config = Mailer.Config.mailgun(key: "{mailGunApi}", domain: "{mailGunDomain}")
+```
+
+#### SendGrid
 
-// or SendGrid
+```swift
 let config = Mailer.Config.sendGrid(key: "{sendGridApiKey}")
+```
+
+#### SMTP
+
+Use the `SMTP` struct as a handle to your SMTP server:
+
+```swift
+let smtp = SMTP(hostname: "smtp.gmail.com",     // SMTP server address
+                   email: "[email protected]",     // username to login
+                password: "password")           // password to login
+                
+let config = Mailer.Config.smtp(smtp)
+```
 
-// Register and configure the service
+<b>Using TLS:</b>
+
+All parameters of `SMTP` struct:
+
+```swift
+let smtp = SMTP(hostname: String,
+                   email: String,
+                password: String,
+                    port: Int32 = 465,
+                  useTLS: Bool = true,
+        tlsConfiguration: TLSConfiguration? = nil,
+             authMethods: [AuthMethod] = [],
+             accessToken: String? = nil,
+              domainName: String = "localhost",
+                 timeout: UInt = 10)
+                 
+let config = Mailer.Config.smtp(smtp)
+```
+
+#### Register service
+
+Register and configure the service.
+
+```swift
 Mailer(config: config, registerOn: &services)
 ```
 
 `Mailer.Config` is an `enum` and you can choose from any integrated services to be used
 
-And send an email:
+#### Send an email
 
 ```swift
 let mail = Mailer.Message(from: "[email protected]", to: "[email protected]", subject: "Oil spill", text: "Oooops I did it again", html: "<p>Oooops I did it again</p>")
@@ -53,6 +93,53 @@ return try req.mail.send(mail).flatMap(to: Response.self) { mailResult in
 }
 ```
 
+## Testing
+
+Mailcore provides a  `MailCoreTestTools` framework which you can import into your tests to get `MailerMock`.
+
+To register, and potentially override any existing "real" Mailer service, just initialize `MailerMock` with your services.
+
+```swift
+// Register
+MailerMock(services: &services)
+
+// Retrieve in your tests
+let mailer = try! req.make(MailerService.self) as! MailerMock
+```
+
+`MailerMock` will store the last used result as well as the received message and request. Structure of the moct can be seen below:
+
+```swift
+public class MailerMock: MailerService {
+
+    public var result: Mailer.Result = .success
+    public var receivedMessage: Mailer.Message?
+    public var receivedRequest: Request?
+
+    // MARK: Initialization
+
+    @discardableResult public init(services: inout Services) {
+        services.remove(type: Mailer.self)
+        services.register(self, as: MailerService.self)
+    }
+
+    // MARK: Public interface
+
+    public func send(_ message: Mailer.Message, on req: Request) throws -> Future<Mailer.Result> {
+        receivedMessage = message
+        receivedRequest = req
+        return req.eventLoop.newSucceededFuture(result: result)
+    }
+
+    public func clear() {
+        result = .success
+        receivedMessage = nil
+        receivedRequest = nil
+    }
+
+}
+```
+
 ## Support
 
 Join our [Slack](http://bit.ly/2B0dEyt), channel <b>#help-boost</b> to ... well, get help :) 
@@ -70,6 +157,12 @@ Core package for <b>[Boost](http://www.boostappstore.com)</b>, a completely open
 * [DBCore](https://github.com/LiveUI/DbCore/) - Set of tools for work with PostgreSQL database
 * [VaporTestTools](https://github.com/LiveUI/VaporTestTools) - Test tools and helpers for Vapor 3
 
+## Implemented thirdparty providers
+
+* <b>MailGun</b> - https://github.com/twof/VaporMailgunService
+* <b>SendGrig</b> - https://github.com/vapor-community/sendgrid-provider
+* <b>SMTP</b> - https://github.com/IBM-Swift/Swift-SMTP
+
 ## Code contributions
 
 We love PR’s, we can’t get enough of them ... so if you have an interesting improvement, bug-fix or a new feature please don’t hesitate to get in touch. If you are not sure about something before you start the development you can always contact our dev and product team through our Slack.

README.md

@@ -0,0 +1,31 @@
+//
+//  Message+SMTP.swift
+//  MailCore
+//
+//  Created by Ondrej Rafaj on 11/04/2018.
+//
+
+import Foundation
+import Vapor
+import SwiftSMTP
+
+
+extension Mailer.Message {
+    
+    func asSmtpMail() -> Mail {
+        let fromUser = User(email: from)
+        
+        let toUser = User(email: to)
+        
+        let attachments: [Attachment]
+        if let html = html {
+            attachments = [Attachment(htmlContent: html)]
+        } else {
+            attachments = []
+        }
+        
+        let mail = Mail(from: fromUser, to: [toUser], subject: subject, text: text, attachments: attachments)
+        return mail
+    }
+    
+}

Sources/MailCore/Extensions/Message+SMTP.swift

@@ -9,22 +9,27 @@ import Foundation
 import Vapor
 import Mailgun
 import SendGrid
+@_exported import SwiftSMTP
 
 
+/// Emailing service
 public protocol MailerService: Service {
     func send(_ message: Mailer.Message, on req: Request) throws -> Future<Mailer.Result>
 }
 
 
+/// Mailer class
 public class Mailer: MailerService {
 
+    /// Basic message
     public struct Message {
         public let from: String
         public let to: String
         public let subject: String
         public let text: String
         public let html: String?
 
+        /// Message init
         public init(from: String, to: String, subject: String, text: String, html: String? = nil) {
             self.from = from
             self.to = to
@@ -34,23 +39,28 @@ public class Mailer: MailerService {
         }
     }
 
+    /// Result returned by the services
     public enum Result {
         case serviceNotConfigured
         case success
         case failure(error: Error)
     }
 
+    /// Service configuration
     public enum Config {
         case none
         case mailgun(key: String, domain: String)
         case sendGrid(key: String)
+        case smtp(SMTP)
     }
 
-    let config: Config
+    /// Current email service configuration
+    var config: Config
 
 
     // MARK: Initialization
 
+    /// Mailer initialization. MailerService get's registered to the services at this point, there is no need to do that manually!
     @discardableResult public init(config: Config, registerOn services: inout Services) throws {
         self.config = config
 
@@ -70,6 +80,7 @@ public class Mailer: MailerService {
 
     // MARK: Public interface
 
+    /// Send a message using a provider defined in `config: Config`
     public func send(_ message: Message, on req: Request) throws -> Future<Mailer.Result> {
         switch config {
         case .mailgun(_, _):
@@ -89,15 +100,19 @@ public class Mailer: MailerService {
                     return Mailer.Result.failure(error: error)
                 }
             )
+        case .smtp(let smtp):
+            let promise = req.eventLoop.newPromise(Mailer.Result.self)
+            smtp.send(message.asSmtpMail()) { error in
+                if let error = error {
+                    promise.succeed(result: Mailer.Result.failure(error: error))
+                } else {
+                    promise.succeed(result: Mailer.Result.success)
+                }
+            }
+            return promise.futureResult
         default:
             return req.eventLoop.newSucceededFuture(result: Mailer.Result.serviceNotConfigured)
         }
     }
 
-    // MARK: Templating
-    
-    public func template(name: String, params: Codable) -> String {
-        return ":)"
-    }
-    
 }

Sources/MailCore/MailCore.swift

@@ -8,7 +8,7 @@
 import Foundation
 import Vapor
 @testable import Service
-import MailCore
+@_exported import MailCore
 import VaporTestTools