Merge pull request #73 from wildbit/task/add-support-for-layout-templ…

…ates

Add support for layout templates

src/Postmark.Tests/ClientTemplateTests.cs

@@ -3,13 +3,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
+using PostmarkDotNet.Model;
 
 namespace Postmark.Tests
 {
     public class ClientTemplateTests : ClientBaseFixture, IDisposable
     {
+        private readonly string _layoutContentPlaceholder = "{{{@content}}}";
+
         protected override void Setup()
         {
             _client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN, BASE_URL);
@@ -20,14 +22,27 @@ public async void ClientCanCreateTemplate()
         {
             var name = Guid.NewGuid().ToString();
             var subject = "A subject: " + Guid.NewGuid();
-            var htmlbody = "<b>Hello, {{name}}</b>";
+            var htmlBody = "<b>Hello, {{name}}</b>";
             var textBody = "Hello, {{name}}!";
 
-            var newTemplate = await _client.CreateTemplateAsync(name, subject, htmlbody, textBody);
+            var newTemplate = await _client.CreateTemplateAsync(name, subject, htmlBody, textBody);
 
             Assert.Equal(name, newTemplate.Name);
         }
 
+        [Fact]
+        public async void ClientCanCreateLayoutTemplates()
+        {
+            var newLayoutTemplate = await GenerateLayoutTemplate();
+            Assert.Equal(TemplateType.Layout, newLayoutTemplate.TemplateType);
+
+            // Creating a standard template that uses the layout template above
+            var newStandardTemplate = await GenerateStandardTemplate(newLayoutTemplate.Alias);
+
+            Assert.Equal(TemplateType.Standard, newStandardTemplate.TemplateType);
+            Assert.Equal(newLayoutTemplate.Alias, newStandardTemplate.LayoutTemplate);
+        }
+
         [Fact]
         public async void ClientCanEditTemplate()
         {
@@ -50,6 +65,22 @@ public async void ClientCanEditTemplate()
             Assert.Equal(existingTemplate.TextBody + existingTemplate.TextBody, updatedTemplate.TextBody);
         }
 
+        [Fact]
+        public async void ClientCanEditLayoutTemplateProperty()
+        {
+            var newLayoutTemplate = await GenerateLayoutTemplate();
+            var newStandardTemplate = await GenerateStandardTemplate(newLayoutTemplate.Alias);
+
+            // Setting the LayoutTemplate to null
+            var templateWithNoLayoutTemplate = await _client.EditTemplateAsync(newStandardTemplate.TemplateId, layoutTemplate: "");
+            Assert.Null(templateWithNoLayoutTemplate.LayoutTemplate);
+
+            // Setting the LayoutTemplate back to the layout template that was created
+            var templateWithLayoutTemplate = await _client.EditTemplateAsync(newStandardTemplate.TemplateId,
+                layoutTemplate: newLayoutTemplate.Alias);
+            Assert.Equal(newLayoutTemplate.Alias, templateWithLayoutTemplate.LayoutTemplate);
+        }
+
         [Fact]
         public async void ClientCanDeleteTemplate()
         {
@@ -84,6 +115,8 @@ public async void ClientCanGetTemplate()
             Assert.True(result.Active);
             Assert.True(result.AssociatedServerId > 0);
             Assert.Equal(newTemplate.TemplateId, result.TemplateId);
+            Assert.Equal(TemplateType.Standard, result.TemplateType);
+            Assert.Null(result.LayoutTemplate);
         }
 
         [Fact]
@@ -103,7 +136,36 @@ public async void ClientCanGetListTemplates()
             Assert.False(result.Templates.FirstOrDefault(k => k.TemplateId == toDelete) != null);
             var offsetResults = await _client.GetTemplatesAsync(5);
             Assert.True(result.Templates.Skip(5).Select(k => k.TemplateId).SequenceEqual(offsetResults.Templates.Select(k => k.TemplateId)));
+        }
+
+        [Fact]
+        public async void GetTemplatesReturnsProperResults()
+        {
+            var newLayoutTemplate = await GenerateLayoutTemplate();
+            var newStandardTemplate = await GenerateStandardTemplate(newLayoutTemplate.Alias);
+
+            var result = await _client.GetTemplatesAsync();
+            Assert.Equal(2, result.TotalCount);
+
+            var standardTemplateFromResult = result.Templates.First(t => t.TemplateId == newStandardTemplate.TemplateId);
+            Assert.Equal(newStandardTemplate.TemplateId, standardTemplateFromResult.TemplateId);
+            Assert.Equal(newStandardTemplate.Alias, standardTemplateFromResult.Alias);
+            Assert.Equal(newStandardTemplate.Name, standardTemplateFromResult.Name);
+            Assert.Equal(TemplateType.Standard, standardTemplateFromResult.TemplateType);
+            Assert.Equal(newLayoutTemplate.Alias, standardTemplateFromResult.LayoutTemplate);
+
+            var layoutTemplateFromResult = result.Templates.First(t => t.TemplateId == newLayoutTemplate.TemplateId);
+            Assert.Equal(newLayoutTemplate.TemplateId, layoutTemplateFromResult.TemplateId);
+            Assert.Equal(newLayoutTemplate.Alias, layoutTemplateFromResult.Alias);
+            Assert.Equal(newLayoutTemplate.Name, layoutTemplateFromResult.Name);
+            Assert.Equal(TemplateType.Layout, layoutTemplateFromResult.TemplateType);
+            Assert.Null(layoutTemplateFromResult.LayoutTemplate);
+
+            var filteredResultByType = await _client.GetTemplatesAsync(0, 100, TemplateTypeFilter.Layout);
+            Assert.Equal(1, filteredResultByType.TotalCount);
 
+            var filteredResultByLayoutAlias = await _client.GetTemplatesAsync(0, 100, TemplateTypeFilter.All, newLayoutTemplate.Alias);
+            Assert.Equal(1, filteredResultByLayoutAlias.TotalCount);
         }
 
         [Fact]
@@ -121,6 +183,23 @@ public async void ClientCanValidateTemplate()
             Assert.Equal(3, products.Length);
         }
 
+        [Fact]
+        public async void ClientCanUseLayoutTemplatesWhenValidating()
+        {
+            var layoutTemplate = await GenerateLayoutTemplate();
+
+            var content = "Mr. Jones";
+            var result = await _client.ValidateTemplateAsync("Subject", null, content, new { }, true, TemplateType.Standard, layoutTemplate.Alias);
+
+            Assert.True(result.AllContentIsValid);
+            Assert.True(result.TextBody.ContentIsValid);
+            Assert.True(result.Subject.ContentIsValid);
+
+            // Testing to see that indeed the validation has used the LayoutTemplate
+            var expectedTextBody = layoutTemplate.TextBody.Replace(_layoutContentPlaceholder, content);
+            Assert.Equal(expectedTextBody, result.TextBody.RenderedContent);
+        }
+
         [Fact]
         public async void ClientCanSendWithTemplate()
         {
@@ -137,7 +216,8 @@ public async void ClientCanSendTemplateWithStringModel()
             Assert.NotEqual(Guid.Empty, sendResult.MessageID);
         }
 
-        private Task Cleanup(){
+        private Task Cleanup()
+        {
             return Task.Run(async () =>
             {
                 try
@@ -155,6 +235,29 @@ private Task Cleanup(){
             });
         }
 
+        private async Task<PostmarkTemplate> GenerateLayoutTemplate()
+        {
+            var layoutName = Guid.NewGuid().ToString();
+            var layoutHtmlBody = $"<b>header</b> {_layoutContentPlaceholder} <b>footer</b>";
+            var layoutTextBody = $"header {_layoutContentPlaceholder} footer";
+
+            var newLayoutTemplate = await _client.CreateTemplateAsync(layoutName, null, layoutHtmlBody, layoutTextBody, null, TemplateType.Layout);
+            return await _client.GetTemplateAsync(newLayoutTemplate.TemplateId);
+        }
+
+        private async Task<PostmarkTemplate> GenerateStandardTemplate(string layoutTemplateAlias = null)
+        {
+            var name = Guid.NewGuid().ToString();
+            var subject = "A subject: " + Guid.NewGuid();
+            var htmlBody = "<b>Hello, {{name}}!</b>";
+            var textBody = "Hello, {{name}}!";
+
+            var newStandardTemplate = await _client.CreateTemplateAsync(name, subject, htmlBody, textBody, null,
+                TemplateType.Standard, layoutTemplateAlias);
+
+            return await _client.GetTemplateAsync(newStandardTemplate.TemplateId);
+        }
+
         public void Dispose()
         {
             Cleanup().Wait();

src/Postmark/Model/PostmarkTemplate.cs

@@ -1,10 +1,13 @@
-namespace PostmarkDotNet.Model
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace PostmarkDotNet.Model
 {
     public class PostmarkTemplate
     {
         public long TemplateId { get; set; }
 
-        public string Alias { get;set; }
+        public string Alias { get; set; }
 
         public string Subject { get; set; }
 
@@ -18,5 +21,9 @@ public class PostmarkTemplate
 
         public bool Active { get; set; }
 
+        [JsonConverter(typeof(StringEnumConverter))]
+        public TemplateType TemplateType { get; set; }
+
+        public string LayoutTemplate { get; set; }
     }
 }

src/Postmark/Model/PostmarkTemplateListingResponse.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 
 namespace PostmarkDotNet.Model
 {
@@ -13,8 +15,16 @@ public class PostmarkTemplateListingResponse
     public class BasicTemplateInformation
     {
         public bool IsActive { get; set; }
+
         public String Name { get; set; }
+
         public long TemplateId { get; set; }
+
         public string Alias { get; set; }
+
+        [JsonConverter(typeof(StringEnumConverter))]
+        public TemplateType TemplateType { get; set; }
+
+        public string LayoutTemplate { get; set; }
     }
 }

src/Postmark/Model/TemplateType.cs

@@ -0,0 +1,8 @@
+namespace PostmarkDotNet.Model
+{
+    public enum TemplateType
+    {
+        Standard,
+        Layout
+    }
+}

src/Postmark/Model/TemplateTypeFilter.cs

@@ -0,0 +1,9 @@
+namespace PostmarkDotNet.Model
+{
+    public enum TemplateTypeFilter
+    {
+        Standard,
+        Layout,
+        All
+    }
+}