Creating a Bulk-Email Management System III

The Service project is a class library project that holds the business logics for CRUD operations relative to the services and repositories as well as mappers. It’s split into 3 distinct folder structures namely, Repositories, Services and Mappers. More details below

2. BabaFunkeEmailManager.Service Project

Step I – Right-click the blank solution to add a New Project. Select the ‘Class Library’ project option; make sure it’s C# and targets .Net Standard or .Net Core. I name mine BabaFunkeEmailManager.Service.

Step 2 – Add the Project References and Nuget Packages

Add a reference to the BabaFunkeEmailManager.Data project since we’ll be referencing the models in the services. Add the following Nuget Packages

Step 3 – Create the Services

We implement all the CRUD related functionalities for the system stopping short of directly interacting with the data layer. Instead, the services call the repositories for any interactions with the data store.

For my interfaces, I create a generic one for basic CRUD operations. In other words, services such as Request, Newsletter and Subscriber all implement methods for creating new entities, requesting existing entities by id or all, updating existing entities and deleting entities from the database. To avoid unnecessary code duplication (think the DRY principle), we simply morph all into one interface that will be implemented by all 3 – IService.

	using BabaFunkeEmailManager.Data.Models;
	using System.Collections.Generic;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Services.Interfaces
	{
	/// <summary>
	/// Generic interface for basic CRUD operations
	/// </summary>
	/// <typeparam name="T">The Model - Subscriber, Request or Newsletter</typeparam>
	public interface IService<T>
	{
	Task<IEnumerable<T>> GetAllItems();
	Task<ServiceResponse<T>> GetItem(string id);
	Task<ServiceResponse<T>> AddItem(T item);
	Task<ServiceResponse<T>> UpdateItem(string id, T item);
	Task<ServiceResponse<T>> DisableItem(string id);
	Task<ServiceResponse<T>> DeleteItem(string id);
	}
	}

view raw IService.cs hosted with

by GitHub

ISubscriberService.cs inherits the generic IService interface to provide a functionality for getting a filtered subscribers list. This is required for sending emails to selected subcategories in our list.

	using BabaFunkeEmailManager.Data.Models;
	using System.Collections.Generic;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Services.Interfaces
	{
	/// <summary>
	/// An extension of the IService<T> interface for geting filtered list of Subscribers
	/// </summary>
	public interface ISubscriberService : IService<Subscriber>
	{
	Task<IEnumerable<Subscriber>> GetAllActiveSubscribersBySubCategory(string subCategory, string PartitionKey = "Subscriber");
	}
	}

view raw ISubscriberService.cs hosted with

by GitHub

	using BabaFunkeEmailManager.Data.Models;
	using FluentEmail.Core.Models;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Services.Interfaces
	{
	/// <summary>
	/// The email sending service interface
	/// </summary>
	public interface IEmailService
	{
	Task<SendResponse> SendEmail(RequestDetail requestDetail);
	}
	}

view raw IEmailService.cs hosted with

by GitHub

	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Services.Interfaces
	{
	/// <summary>
	/// An interface for adding items to a Message Queue
	/// </summary>
	/// <typeparam name="T"></typeparam>
	public interface IQueueService<T>
	{
	Task AddItemToQueue(T item);
	}
	}

view raw IQueueService.cs hosted with

by GitHub

For the corresponding implementation of the interfaces above, I touch on two examples for brevity. The complete implementation can be found in the GitHub project.

The QueueService’s sole responsibility is to add a RequestDetail object to the MessageQueue where it’ll be picked up and deserialized for sending via the EmailService. Any addition to this queue, triggers a call to the Queue Trigger Azure Function or Webjob which will be created later.

	using Azure.Storage.Queues;
	using BabaFunkeEmailManager.Data.Models;
	using BabaFunkeEmailManager.Service.Services.Interfaces;
	using System;
	using System.Text;
	using System.Text.Json;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Services.Implementations
	{
	public class QueueService : IQueueService<RequestDetail>
	{
	private readonly QueueClient _queueClient;

	public QueueService(QueueClient queueClient)
	{
	_queueClient = queueClient;
	}

	public async Task AddItemToQueue(RequestDetail request)
	{
	_queueClient.Create();
	var plainTextBytes = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(request));
	var msg = Convert.ToBase64String(plainTextBytes);
	await _queueClient.SendMessageAsync(msg);
	}
	}
	}

view raw QueueService.cs hosted with

by GitHub

The EmailService uses the FluentEmailFactory exposed by the FluentEmail Nuget package to end out emails. My private BuildEmail method creates a structure for the email by adding a header, footer and body. Some of the elements of the email structure e.g. body (actual content of the email), name of recipient will be provided in each request detail object. FluentEmail does support templates so you could explore the option as an alternative to my hardcoded structure in the private method.

	using BabaFunkeEmailManager.Data.Models;
	using BabaFunkeEmailManager.Service.Services.Interfaces;
	using BabaFunkeEmailManager.Service.Utilities;
	using FluentEmail.Core;
	using FluentEmail.Core.Models;
	using System;
	using System.Text;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Services.Implementations
	{
	public class EmailService : IEmailService
	{
	private readonly IFluentEmailFactory _fluentEmailFactory;

	public EmailService(IFluentEmailFactory fluentEmailFactory)
	{
	_fluentEmailFactory = fluentEmailFactory;
	}

	public async Task<SendResponse> SendEmail(RequestDetail requestDetail)
	{
	try
	{
	var mail = _fluentEmailFactory.Create()
	.To($"{requestDetail.SubscriberEmail}")
	.Subject(requestDetail.EmailSubject)
	.Body(BuildEmail(requestDetail.SubscriberEmail, requestDetail.EmailBody, requestDetail.SubscriberFirstname), true);

	return await mail.SendAsync();
	}
	catch (Exception ex)
	{
	throw new Exception(ex.Message, ex);
	}
	}

	private string BuildEmail(string email, string body, string name)
	{
	var unsubscribeLink = $"{ServiceUtil.ClientUrl}Subscriber/Unsubscribe?email=" + email;

	var builder = new StringBuilder();

	var subscriberFirstname = string.IsNullOrEmpty(name) ? "Friend" : name;

	var header = $"Hello {subscriberFirstname},<p></p>";
	var footer = $"<p></p><p></p>If you no longer wish to hear from me, click <a href={unsubscribeLink}>Unsubscribe</a>." +
	$"<p>Best regards,</p><p>Adebayo Adegbembo</p>" +
	$"<p><a href='https://www.linkedin.com/in/adebayoadegbembo/'>LinkedIn</a> \| <a href='https://daddycreates.com/'>Blog</a></p>";

	builder.AppendLine(header);
	builder.AppendLine(body);
	builder.AppendLine(footer);

	return builder.ToString();
	}
	}
	}

view raw EmailService.cs hosted with

by GitHub

Step 4 – Create the Repositories

We create the interfaces and implementation that directly communicate with our Data Store, Azure Table Storage. The 3 main tables are Subscriber, Newsletter and RequestHeader so we define their corresponding repos as below.

First the interfaces,

	using Microsoft.Azure.Cosmos.Table;
	using System.Collections.Generic;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Repositories.Interfaces
	{
	/// <summary>
	/// A generic interface for CRUD operations to and from Azure Table Storage
	/// </summary>
	/// <typeparam name="T">Entity</typeparam>
	public interface IRepository<T> where T: TableEntity
	{
	Task<IEnumerable<T>> GetAllEntities();
	Task<T> GetEntity(string rowKey, string partitionKey);
	Task<bool> AddEntity(T entity);
	Task<bool> UpdateEntity(T entity);
	Task<bool> DiableEntity(T entity);
	Task<bool> DeleteEntity(T entity);
	}
	}

view raw IRepository.cs hosted with

by GitHub

	using BabaFunkeEmailManager.Data.Entities;
	using System.Collections.Generic;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Repositories.Interfaces
	{
	public interface ISubscriberRepository : IRepository<SubscriberEntity>
	{
	Task<IEnumerable<SubscriberEntity>> GetAllEntitiesBySubCategory(string subCategory);
	}
	}

view raw ISubscriberRepository.cs hosted with

by GitHub

And the implementations. For brevity, I share only the SubscriberRepository here.

	using BabaFunkeEmailManager.Data.Entities;
	using BabaFunkeEmailManager.Service.Repositories.Interfaces;
	using BabaFunkeEmailManager.Service.Utilities;
	using Microsoft.Azure.Cosmos.Table;
	using System.Collections.Generic;
	using System.Threading.Tasks;

	namespace BabaFunkeEmailManager.Service.Repositories.Implementations
	{
	public class SubscriberRepository : ISubscriberRepository
	{
	private readonly CloudTable _cloudTable;
	private readonly CloudTableClient _cloudTableClient;

	public SubscriberRepository(CloudTable cloudTable, CloudTableClient cloudTableClient)
	{
	_cloudTable = cloudTable;
	_cloudTableClient = cloudTableClient;
	_cloudTable = _cloudTableClient.GetTableReference(ServiceUtil.SubscriberTable);
	}

	public async Task<IEnumerable<SubscriberEntity>> GetAllEntities()
	{
	var query = new TableQuery<SubscriberEntity>();
	var entities = await _cloudTable.ExecuteQuerySegmentedAsync(query, null);
	return entities;
	}

	public async Task<IEnumerable<SubscriberEntity>> GetAllEntitiesBySubCategory(string subCategory)
	{
	var query1 = TableQuery.GenerateFilterCondition("SubCategory", QueryComparisons.Equal, subCategory);
	var query2 = TableQuery.GenerateFilterConditionForBool("IsSubscribed", QueryComparisons.Equal, true);
	var query = new TableQuery<SubscriberEntity>()
	.Where(TableQuery.CombineFilters(query1, TableOperators.And, query2));
	var entities = await _cloudTable.ExecuteQuerySegmentedAsync(query, null);
	return entities;
	}

	public async Task<SubscriberEntity> GetEntity(string rowKey, string partitionKey)
	{
	var operation = TableOperation.Retrieve<SubscriberEntity>(partitionKey, rowKey);
	var result = await _cloudTable.ExecuteAsync(operation);
	return result.Result as SubscriberEntity;
	}

	public async Task<bool> AddEntity(SubscriberEntity entity)
	{
	var operation = TableOperation.Insert(entity);
	await _cloudTable.ExecuteAsync(operation);
	return true;
	}

	public async Task<bool> UpdateEntity(SubscriberEntity entity)
	{
	entity.ETag = "*";
	var operation = TableOperation.Replace(entity);
	await _cloudTable.ExecuteAsync(operation);
	return true;
	}

	public async Task<bool> DiableEntity(SubscriberEntity entity)
	{
	var operation = TableOperation.InsertOrReplace(entity);
	await _cloudTable.ExecuteAsync(operation);
	return true;
	}

	public async Task<bool> DeleteEntity(SubscriberEntity entity)
	{
	entity.ETag = "*";
	var operation = TableOperation.Delete(entity);
	await _cloudTable.ExecuteAsync(operation);
	return true;
	}
	}
	}

view raw SubscriberRepository.cs hosted with

by GitHub

Step 5 – Create the Mappers

Finally, we have the mappers which act as the bridge between the models and entities. I prefer a custom mapper to AutoMapper since this is a simple scenario. Recall that the entities directly communicate with the Data Store while the models are client-facing.

First a generic interface,

	using Microsoft.Azure.Cosmos.Table;
	using System.Collections.Generic;

	namespace BabaFunkeEmailManager.Service.Mappers
	{
	public interface IMapper<T, U> where U: TableEntity
	{
	IEnumerable<T> AllEntitiesToModels(IEnumerable<U> entities);
	T EntityToModel(U entity);
	U ModelToEntity(T item);
	}
	}

view raw IMapper.cs hosted with

by GitHub

And the implementation for corresponding model/entity relationship.

	using BabaFunkeEmailManager.Data.Entities;
	using BabaFunkeEmailManager.Data.Models;
	using System.Collections.Generic;
	using System.Linq;

	namespace BabaFunkeEmailManager.Service.Mappers
	{
	public class SubscriberMapper : IMapper<Subscriber, SubscriberEntity>
	{
	public IEnumerable<Subscriber> AllEntitiesToModels(IEnumerable<SubscriberEntity> entities)
	{
	return entities.Select(e => new Subscriber
	{
	Id = e.Id,
	Firstname = e.Firstname,
	Lastname = e.Lastname,
	Email = e.RowKey,
	Category = e.PartitionKey,
	SubCategory = e.SubCategory,
	IsSubscribed = e.IsSubscribed,
	SubscribedOn = e.SubscribedOn,
	UnsubscribedOn = e.UnsubscribedOn
	}).ToList();
	}

	public Subscriber EntityToModel(SubscriberEntity entity)
	{
	return new Subscriber
	{
	Id = entity.Id,
	Firstname = entity.Firstname,
	Lastname = entity.Lastname,
	Email = entity.RowKey,
	Category = entity.PartitionKey,
	SubCategory = entity.SubCategory,
	IsSubscribed = entity.IsSubscribed,
	SubscribedOn = entity.SubscribedOn,
	UnsubscribedOn = entity.UnsubscribedOn
	};
	}

	public SubscriberEntity ModelToEntity(Subscriber subscriber)
	{
	return new SubscriberEntity
	{
	RowKey = subscriber.Email.Replace(" ", "").ToLower(),
	PartitionKey = subscriber.Category,
	Id = subscriber.Id,
	Firstname = subscriber.Firstname,
	Lastname = subscriber.Lastname,
	SubCategory= subscriber.SubCategory,
	IsSubscribed = subscriber.IsSubscribed,
	SubscribedOn = subscriber.SubscribedOn,
	UnsubscribedOn = subscriber.UnsubscribedOn
	};
	}
	}
	}

view raw SubscriberMapper.cs hosted with

by GitHub

Conclusion

That’s it for the Services. The logical split of the system into projects ensures we have a proper organization and makes it easy to re-use shared resources as we’ll see. In Part IV, I focus on the APIs. Note that the project is available on Github for ease of replicating.

2. BabaFunkeEmailManager.Service Project

Baba Funke