xMessageService/Providers/XSmsService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using PhoneNumbers;
using RestSharp;
using xCommons.Extensions;
using xExceptions.Constants;
using xMessageService.Interfaces;
using xMessageService.Models;

namespace xMessageService.Providers {
    public partial class XSmsService : IXSmsService {
        private string serviceUrl;
        private readonly string defaultProvider;
        private readonly IDictionary<string, XSmsConfiguration> configurations;

        public XSmsService (
            string defaultProvider,
            IDictionary<string, XSmsConfiguration> configurations
        ) {
            this.defaultProvider = defaultProvider;
            this.configurations = configurations;

            //
            PrepareServiceUrl ();
        }

        public Task SendSmsAsync (
            XMessage message,
            string provider = null
        ) {
            //
            // Run Send SMS Asynchronous ...
            return Task.Run (() => {
                SendSMS (message, provider);
            });
        }

        #region Private ...
        /// <summary>
        /// Prepare Service Url for Specified/Default Provider
        /// </summary>
        /// <param name="provider"></param>
        private void PrepareServiceUrl (string provider = null) {
            //
            if (provider.IsNullOrEmpty ()) {
                provider = defaultProvider;
            }

            //
            var config = GetConfiguration (provider);
            if (config.IsNull ()) {
                return;
            }

            //
            serviceUrl = config.ServiceUrl;
            serviceUrl += "&username=" + config.Username + "&password=" + config.Password + "&";
        }

        /// <summary>
        /// Prepare Service url for Integrating XMessage by 
        /// using Specified/Default Provider Configurations
        /// </summary>
        /// <param name="message"></param>
        /// <param name="provider"></param>
        private void PrepareSmsMessage (
            XMessage message,
            string provider = null
        ) {
            //
            if (message == null ||
                message.Message.IsNullOrEmpty () ||
                message.Recievers.Count == 0) {
                XException.InvalidMessage.Throw ();
            }

            //
            // Validating Mobile Numbers ...
            var phoneNumberUtil = PhoneNumbers.PhoneNumberUtil.GetInstance ();
            var recieversList = "";

            //
            PrepareServiceUrl (provider);

            //
            foreach (var reciever in message.Recievers) {
                try {
                    //
                    var mPhoneNumber = phoneNumberUtil.Parse (reciever, null);
                    if (phoneNumberUtil.IsValidNumber (mPhoneNumber)) {
                        //
                        // Format Phone Numbers to the '+989120000000' pattern ...
                        var recieverPhone = phoneNumberUtil.Format (mPhoneNumber, PhoneNumberFormat.E164);
                        if (recieversList.Length > 0) {
                            recieversList += ",";
                        }
                        recieversList += reciever;
                    }
                } catch { }
            }

            //
            var config = GetConfiguration ();

            //
            // Preparing All Content and Configurations for Sending Messages ...
            serviceUrl += "to=" +
                recieversList +
                "&message=" +
                message.Message +
                "&from=" +
                config.LineNumber +
                "&flash=" +
                false;
        }

        /// <summary>
        /// Send a Message as SMS by Specified/Default Provider
        /// </summary>
        /// <param name="message"></param>
        /// <param name="provider"></param>
        private void SendSMS (
            XMessage message,
            string provider = null
        ) {
            //
            if (serviceUrl.IsNullOrEmpty ()) {
                //
                Console.WriteLine ($"SMS Error: MessageServiceInitialFailed ...");
                XException.MessageServiceInitialFailed.Throw ();
            }

            //
            try {
                //
                // preparing Service Url based on message data ...
                PrepareSmsMessage (message, provider);

                //
                // Implementing Service Calling Using RestSharp Library ...
                // We Select RestSharp because it supports Sync/Async Calls ...
                var client = new RestClient (serviceUrl);
                var request = new RestRequest (Method.POST);

                //
                // Send Request ...
                var response = client.Execute (request);
            } catch (Exception ex) {
                Console.WriteLine ($"SMS Error: {ex.Message}");
                XException.MessageServiceInitialFailed.Throw ();
            }
        }

        /// <summary>
        /// Validate and Retrieve Provider Configuration for Service
        /// </summary>
        /// <param name="provider"></param>
        /// <returns></returns>
        private XSmsConfiguration GetConfiguration (string provider = null) {
            //
            if (
                provider.IsNullOrEmpty () ||
                provider.ToNormalString () == "empty"
            ) {
                //
                provider = defaultProvider;
                return null;
            }

            //
            if (!configurations.Keys.Contains (provider)) {
                XException.MessageServiceInitialFailed.Throw ();
            }

            //
            return configurations[provider];
        }
        #endregion        
    }
}