///*
// *
// * (c) Copyright Ascensio System Limited 2010-2018
// *
// * This program is freeware. You can redistribute it and/or modify it under the terms of the GNU 
// * General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html). 
// * In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that 
// * Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
// *
// * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
// * FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
// *
// * You can contact Ascensio System SIA by email at sales@onlyoffice.com
// *
// * The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display 
// * Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
// *
// * Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains 
// * relevant author attributions when distributing the software. If the display of the logo in its graphic 
// * form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE" 
// * in every copy of the program you distribute. 
// * Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
// *
//*/


//#region Import

//using ASC.Common.Caching;
//using ASC.Common.Logging;
//using ASC.Common.Threading.Progress;
//using ASC.Core;
//using ASC.Core.Common.Settings;
//using ASC.Core.Tenants;
//using ASC.CRM.Classes;
//using ASC.CRM.Core;
//using ASC.CRM.Core.Dao;
//using ASC.CRM.Core.Entities;
//using ASC.CRM.Core.Enums;
//using ASC.CRM.Resources;
//using ASC.Web.CRM.Core;
//using ASC.Web.Files.Api;
//using Autofac;
//using MailKit;
//using MailKit.Net.Smtp;
//using MailKit.Security;
//using Microsoft.Extensions.Configuration;
//using Microsoft.Extensions.Options;
//using MimeKit;
//using Newtonsoft.Json.Linq;
//using System;
//using System.Collections.Generic;
//using System.IO;
//using System.Linq;
//using System.Net.Sockets;
//using System.Runtime.Serialization;
//using System.Text;
//using System.Text.RegularExpressions;
//using System.Threading;
//using File = System.IO.File;
//using SmtpClient = MailKit.Net.Smtp.SmtpClient;

//#endregion

//namespace ASC.Web.CRM.Classes
//{
//    public class SendBatchEmailsOperation : IProgressItem, IDisposable
//    {
//        private readonly bool _storeInHistory;
//        private readonly ILog _log;
//        private readonly SMTPServerSetting _smtpSetting;
//        private readonly Guid _currUser;
//        private readonly int _tenantID;
//        private readonly List<int> _contactID;
//        private readonly String _subject;
//        private readonly String _bodyTempate;
//        private readonly List<int> _fileID;
//        private int historyCategory;
//        private double _exactPercentageValue = 0;

//        public object Id { get; set; }
//        public object Status { get; set; }
//        public object Error { get; set; }
//        public double Percentage { get; set; }
//        public bool IsCompleted { get; set; }

//        private SendBatchEmailsOperation()
//        {
//        }

//        public SendBatchEmailsOperation(
//              List<int> fileID,
//              List<int> contactID,
//              String subject,
//              String bodyTempate,
//              bool storeInHistory,
//              TenantUtil tenantUtil,
//              IOptionsMonitor<ILog> logger,
//              Global global,
//              SecurityContext securityContext,
//              TenantManager tenantManager,
//              UserManager userManager,
//              AuthManager authManager,
//              SettingsManager settingsManager,
//              MailSenderDataCache mailSenderDataCache
//             )
//        {
//            TenantUtil = tenantUtil;
//            SecurityContext = securityContext;

//            Percentage = 0;

//            _fileID = fileID;
//            _contactID = contactID;
//            _subject = subject;
//            _bodyTempate = bodyTempate;

//            _log = logger.Get("ASC.CRM.MailSender");

//            _tenantID = tenantManager.GetCurrentTenant().TenantId;
//            _smtpSetting = settingsManager.Load<CRMSettings>().SMTPServerSetting;
//            _currUser = SecurityContext.CurrentAccount.ID;
//            _storeInHistory = storeInHistory;

//            Status = new
//            {
//                RecipientCount = _contactID.Count,
//                EstimatedTime = 0,
//                DeliveryCount = 0
//            };

//            AuthManager = authManager;
//            UserManager = userManager;
//            MailSenderDataCache = mailSenderDataCache;
//        }

//        public FilesIntegration FilesIntegration { get; }

//        public MailSenderDataCache MailSenderDataCache { get; }
//        public AuthManager AuthManager { get; }

//        public UserManager UserManager { get; }

//        public TenantManager TenantManager { get; }

//        public SecurityContext SecurityContext { get; }

//        public TenantUtil TenantUtil { get; }

//        private void AddToHistory(int contactID, String content, DaoFactory _daoFactory)
//        {
//            if (contactID == 0 || String.IsNullOrEmpty(content)) return;

//            var historyEvent = new RelationshipEvent()
//            {
//                ContactID = contactID,
//                Content = content,
//                CreateBy = _currUser,
//                CreateOn = TenantUtil.DateTimeNow(),
//            };
//            if (historyCategory == 0)
//            {
//                var listItemDao = _daoFactory.GetListItemDao();

//                // HACK
//                var listItem = listItemDao.GetItems(ListType.HistoryCategory).Find(item => item.AdditionalParams == "event_category_email.png");
//                if (listItem == null)
//                {
//                    listItemDao.CreateItem(
//                        ListType.HistoryCategory,
//                        new ListItem { AdditionalParams = "event_category_email.png", Title = CRMCommonResource.HistoryCategory_Note });
//                }
//                historyCategory = listItem.ID;
//            }

//            historyEvent.CategoryID = historyCategory;

//            var relationshipEventDao = _daoFactory.GetRelationshipEventDao();

//            historyEvent = relationshipEventDao.CreateItem(historyEvent);

//            if (historyEvent.ID > 0 && _fileID != null && _fileID.Count > 0)
//            {
//                relationshipEventDao.AttachFiles(historyEvent.ID, _fileID.ToArray());
//            }
//        }

//        public void RunJob()
//        {
//            SmtpClient smtpClient = null;
//            try
//            {
//                TenantManager.SetCurrentTenant(_tenantID);
//                SecurityContext.AuthenticateMe(AuthManager.GetAccountByID(_tenantID, _currUser));

//                smtpClient = GetSmtpClient();

//                var userCulture = UserManager.GetUsers(_currUser).GetCulture();

//                Thread.CurrentThread.CurrentCulture = userCulture;
//                Thread.CurrentThread.CurrentUICulture = userCulture;

//                var contactCount = _contactID.Count;

//                if (contactCount == 0)
//                {
//                    Complete();
//                    return;
//                }

//                MailSenderDataCache.Insert((SendBatchEmailsOperation)Clone());

//                var from = new MailboxAddress(_smtpSetting.SenderDisplayName, _smtpSetting.SenderEmailAddress);
//                var filePaths = new List<string>();
//                var fileDao = FilesIntegration.DaoFactory.GetFileDao<int>();

//                foreach (var fileID in _fileID)
//                {
//                    var fileObj = fileDao.GetFile(fileID);
//                    if (fileObj == null) continue;
//                    using (var fileStream = fileDao.GetFileStream(fileObj))
//                    {
//                        var directoryPath = Path.Combine(Path.GetTempPath(), "teamlab", _tenantID.ToString(),
//                            "crm/files/mailsender/");

//                        if (!Directory.Exists(directoryPath))
//                        {
//                            Directory.CreateDirectory(directoryPath);
//                        }

//                        var filePath = Path.Combine(directoryPath, fileObj.Title);

//                        using (var newFileStream = File.Create(filePath))
//                        {
//                            fileStream.StreamCopyTo(newFileStream);
//                        }

//                        filePaths.Add(filePath);

//                    }
//                }

//                var templateManager = new MailTemplateManager(DaoFactory);
//                var deliveryCount = 0;

//                try
//                {
//                    Error = string.Empty;
//                    foreach (var contactID in _contactID)
//                    {
//                        _exactPercentageValue += 100.0 / contactCount;
//                        Percentage = Math.Round(_exactPercentageValue);

//                        if (IsCompleted) break; // User selected cancel

//                        var contactInfoDao = DaoFactory.GetContactInfoDao();

//                        var startDate = DateTime.Now;

//                        var contactEmails = contactInfoDao.GetList(contactID, ContactInfoType.Email, null, true);
//                        if (contactEmails.Count == 0)
//                        {
//                            continue;
//                        }

//                        var recipientEmail = contactEmails[0].Data;

//                        if (!recipientEmail.TestEmailRegex())
//                        {
//                            Error += string.Format(CRMCommonResource.MailSender_InvalidEmail, recipientEmail) +
//                                     "<br/>";
//                            continue;
//                        }

//                        var to = new MailboxAddress(recipientEmail);

//                        var mimeMessage = new MimeMessage
//                        {
//                            Subject = _subject
//                        };

//                        mimeMessage.From.Add(from);
//                        mimeMessage.To.Add(to);

//                        var bodyBuilder = new BodyBuilder
//                        {
//                            HtmlBody = templateManager.Apply(_bodyTempate, contactID)
//                        };

//                        foreach (var filePath in filePaths)
//                        {
//                            bodyBuilder.Attachments.Add(filePath);
//                        }

//                        mimeMessage.Body = bodyBuilder.ToMessageBody();

//                        mimeMessage.Headers.Add("Auto-Submitted", "auto-generated");

//                        _log.Debug(GetLoggerRow(mimeMessage));

//                        var success = false;

//                        try
//                        {
//                            smtpClient.Send(mimeMessage);

//                            success = true;
//                        }
//                        catch (SmtpCommandException ex)
//                        {
//                            _log.Error(Error, ex);

//                            Error += string.Format(CRMCommonResource.MailSender_FailedDeliverException, recipientEmail) + "<br/>";
//                        }

//                        if (success)
//                        {
//                            if (_storeInHistory)
//                            {
//                                AddToHistory(contactID, string.Format(CRMCommonResource.MailHistoryEventTemplate, mimeMessage.Subject), DaoFactory);
//                            }

//                            var endDate = DateTime.Now;
//                            var waitInterval = endDate.Subtract(startDate);

//                            deliveryCount++;

//                            var estimatedTime =
//                                TimeSpan.FromTicks(waitInterval.Ticks * (_contactID.Count - deliveryCount));

//                            Status = new
//                            {
//                                RecipientCount = _contactID.Count,
//                                EstimatedTime = estimatedTime.ToString(),
//                                DeliveryCount = deliveryCount
//                            };
//                        }

//                        if (MailSenderDataCache.CheckCancelFlag())
//                        {
//                            MailSenderDataCache.ResetAll();

//                            throw new OperationCanceledException();
//                        }

//                        MailSenderDataCache.Insert((SendBatchEmailsOperation)Clone());

//                        if (Percentage > 100)
//                        {
//                            Percentage = 100;

//                            if (MailSenderDataCache.CheckCancelFlag())
//                            {
//                                MailSenderDataCache.ResetAll();

//                                throw new OperationCanceledException();
//                            }

//                            MailSenderDataCache.Insert((SendBatchEmailsOperation)Clone());

//                        }
//                    }
//                }
//                catch (OperationCanceledException)
//                {
//                    _log.Debug("cancel mail sender");
//                }
//                finally
//                {
//                    foreach (var filePath in filePaths)
//                    {
//                        if (File.Exists(filePath))
//                        {
//                            File.Delete(filePath);
//                        }
//                    }
//                }

//                Status = new
//                {
//                    RecipientCount = _contactID.Count,
//                    EstimatedTime = TimeSpan.Zero.ToString(),
//                    DeliveryCount = deliveryCount
//                };




































//            }
//            catch (SocketException e)
//            {
//                Error = e.Message;
//                _log.Error(Error);
//            }
//            finally
//            {
//                if (smtpClient != null)
//                {
//                    smtpClient.Dispose();
//                }
//                Complete();
//            }
//        }

//        public string GetLoggerRow(MimeMessage mailMessage)
//        {
//            if (mailMessage == null)
//                return String.Empty;

//            var result = new StringBuilder();

//            result.AppendLine("From:" + mailMessage.From);
//            result.AppendLine("To:" + mailMessage.To[0]);
//            result.AppendLine("Subject:" + mailMessage.Subject);
//            result.AppendLine("Body:" + mailMessage.Body);
//            result.AppendLine("TenantID:" + _tenantID);

//            foreach (var attachment in mailMessage.Attachments)
//            {
//                result.AppendLine("Attachment: " + attachment.ContentDisposition.FileName);
//            }

//            return result.ToString();
//        }

//        public object Clone()
//        {
//            var cloneObj = new SendBatchEmailsOperation();

//            cloneObj.Error = Error;
//            cloneObj.Id = Id;
//            cloneObj.IsCompleted = IsCompleted;
//            cloneObj.Percentage = Percentage;
//            cloneObj.Status = Status;

//            return cloneObj;
//        }

//        private void DeleteFiles()
//        {
//            if (_fileID == null || _fileID.Count == 0) return;

//            var fileDao = FilesIntegration.DaoFactory.GetFileDao<int>();

//            foreach (var fileID in _fileID)
//            {
//                var fileObj = fileDao.GetFile(fileID);
//                if (fileObj == null) continue;

//                fileDao.DeleteFile(fileObj.ID);
//            }

//        }

//        private SmtpClient GetSmtpClient()
//        {
//            var client = new SmtpClient
//            {
//                ServerCertificateValidationCallback = (sender, certificate, chain, errors) =>
//                    WorkContext.IsMono || MailKit.MailService.DefaultServerCertificateValidationCallback(sender, certificate, chain, errors),
//                Timeout = (int)TimeSpan.FromSeconds(30).TotalMilliseconds
//            };

//            client.Connect(_smtpSetting.Host, _smtpSetting.Port,
//                    _smtpSetting.EnableSSL ? SecureSocketOptions.Auto : SecureSocketOptions.None);

//            if (_smtpSetting.RequiredHostAuthentication)
//            {
//                client.Authenticate(_smtpSetting.HostLogin, _smtpSetting.HostPassword);
//            }

//            return client;
//        }

//        private void Complete()
//        {
//            IsCompleted = true;
//            Percentage = 100;
//            _log.Debug("Completed");

//            MailSenderDataCache.Insert((SendBatchEmailsOperation)Clone());

//            Thread.Sleep(10000);
//            MailSenderDataCache.ResetAll();
//        }

//        public override bool Equals(object obj)
//        {
//            if (obj == null || !(obj is SendBatchEmailsOperation)) return false;

//            var curOperation = (SendBatchEmailsOperation)obj;
//            return (curOperation.Id == Id) && (curOperation._tenantID == _tenantID);
//        }

//        public override int GetHashCode()
//        {
//            return Id.GetHashCode() ^ _tenantID.GetHashCode();
//        }

//        public void Dispose()
//        {
//            DeleteFiles();
//        }
//    }

//    public class MailSenderDataCache
//    {
//        public MailSenderDataCache(TenantManager tenantManager)
//        {
//            TenantID = tenantManager.GetCurrentTenant().TenantId;
//        }

//        public int TenantID { get; }

//        public readonly ICache Cache = ICache.Memory;

//        public string GetStateCacheKey()
//        {
//            return string.Format("{0}:crm:queue:sendbatchemails", TenantID);
//        }

//        public string GetCancelCacheKey()
//        {
//            return string.Format("{0}:crm:queue:sendbatchemails:cancel", TenantID);
//        }

//        public SendBatchEmailsOperation Get()
//        {
//            return Cache.Get<SendBatchEmailsOperation>(GetStateCacheKey());
//        }

//        public void Insert(SendBatchEmailsOperation data)
//        {
//            Cache.Insert(GetStateCacheKey(), data, TimeSpan.FromMinutes(1));
//        }

//        public bool CheckCancelFlag()
//        {
//            var fromCache = Cache.Get<String>(GetCancelCacheKey());

//            if (!String.IsNullOrEmpty(fromCache))
//                return true;

//            return false;

//        }

//        public void SetCancelFlag()
//        {
//            Cache.Insert(GetCancelCacheKey(), "true", TimeSpan.FromMinutes(1));
//        }

//        public void ResetAll()
//        {
//            Cache.Remove(GetStateCacheKey());
//            Cache.Remove(GetCancelCacheKey());
//        }
//    }

//    public class MailSender
//    {
//        private readonly Object _syncObj = new Object();
//        private readonly ProgressQueue _mailQueue = new ProgressQueue(2, TimeSpan.FromSeconds(60), true);
//        private readonly int quotas = 50;

//        public MailSender(
//                          IConfiguration configuration,
//                          TenantManager tenantManager,
//                          SettingsManager settingsManager,
//                          MailSenderDataCache mailSenderDataCache
//                        )
//        {
//            TenantID = tenantManager.GetCurrentTenant().TenantId;
//            MailSenderDataCache = mailSenderDataCache;

//            int parsed;

//            if (int.TryParse(configuration["crm:mailsender:quotas"], out parsed))
//            {
//                quotas = parsed;
//            }

//            TenantManager = tenantManager;
//            SettingsManager = settingsManager;

//            //            LogManager = logger.Get();
//        }

//        public TenantManager TenantManager { get; }
//        public SettingsManager SettingsManager { get; }

//        public MailSenderDataCache MailSenderDataCache { get; }
//        public int TenantID { get; }

//        public IOptionsMonitor<ILog> LogManager { get; }

//        public int GetQuotas()
//        {
//            return quotas;
//        }

//        public IProgressItem Start(List<int> fileID, List<int> contactID, String subject, String bodyTemplate, bool storeInHistory)
//        {
//            lock (_syncObj)
//            {
//                var operation = _mailQueue.GetStatus(TenantID);

//                if (operation == null)
//                {
//                    var mailSender = MailSenderDataCache.Get();

//                    if (mailSender != null)
//                        return mailSender;
//                }

//                if (operation == null)
//                {
//                    if (fileID == null)
//                    {
//                        fileID = new List<int>();
//                    }
//                    if (contactID == null || contactID.Count == 0 ||
//                        String.IsNullOrEmpty(subject) || String.IsNullOrEmpty(bodyTemplate))
//                    {
//                        return null;
//                    }

//                    if (contactID.Count > GetQuotas())
//                    {
//                        contactID = contactID.Take(GetQuotas()).ToList();
//                    }

//                    operation = new SendBatchEmailsOperation(fileID, contactID, subject, bodyTemplate, storeInHistory);
//                    _mailQueue.Add(operation);
//                }

//                if (!_mailQueue.IsStarted)
//                {
//                    _mailQueue.Start(x => x.RunJob());
//                }
//                return operation;
//            }
//        }

//        private SmtpClient GetSmtpClient(SMTPServerSetting smtpSetting)
//        {
//            var client = new SmtpClient
//            {
//                ServerCertificateValidationCallback = (sender, certificate, chain, errors) => MailService.DefaultServerCertificateValidationCallback(sender, certificate, chain, errors),
//                Timeout = (int)TimeSpan.FromSeconds(30).TotalMilliseconds
//            };

//            client.Connect(smtpSetting.Host, smtpSetting.Port,
//                    smtpSetting.EnableSSL ? SecureSocketOptions.Auto : SecureSocketOptions.None);

//            if (smtpSetting.RequiredHostAuthentication)
//            {
//                client.Authenticate(smtpSetting.HostLogin, smtpSetting.HostPassword);
//            }

//            return client;
//        }

//        public void StartSendTestMail(string recipientEmail, string mailSubj, string mailBody)
//        {
//            var log = LogManager.Get("ASC.CRM.MailSender");

//            if (!recipientEmail.TestEmailRegex())
//            {
//                throw new Exception(string.Format(CRMCommonResource.MailSender_InvalidEmail, recipientEmail));
//            }

//            TenantManager.SetCurrentTenant(TenantID);
//            var smtpSetting = SettingsManager.Load<CRMSettings>().SMTPServerSetting;

//            ThreadPool.QueueUserWorkItem(_ =>
//            {
//                try
//                {
//                    var toAddress = new MailboxAddress(recipientEmail);
//                    var fromAddress = new MailboxAddress(smtpSetting.SenderDisplayName, smtpSetting.SenderEmailAddress);

//                    var mimeMessage = new MimeMessage
//                    {
//                        Subject = mailSubj
//                    };

//                    mimeMessage.From.Add(fromAddress);

//                    mimeMessage.To.Add(toAddress);

//                    var bodyBuilder = new BodyBuilder
//                    {
//                        TextBody = mailBody
//                    };

//                    mimeMessage.Body = bodyBuilder.ToMessageBody();

//                    mimeMessage.Headers.Add("Auto-Submitted", "auto-generated");

//                    using (var smtpClient = GetSmtpClient(smtpSetting))
//                    {
//                        smtpClient.Send(FormatOptions.Default, mimeMessage, CancellationToken.None);
//                    }
//                }
//                catch (Exception ex)
//                {
//                    log.Error(ex);
//                }
//            });
//        }

//        public IProgressItem GetStatus()
//        {
//            var result = _mailQueue.GetStatus(TenantID);

//            if (result == null)
//                return MailSenderDataCache.Get();

//            return result;
//        }

//        public void Cancel()
//        {
//            lock (_syncObj)
//            {
//                var findedItem = _mailQueue.GetItems().Where(elem => (int)elem.Id == TenantID);

//                if (findedItem.Any())
//                {
//                    _mailQueue.Remove(findedItem.ElementAt(0));

//                    MailSenderDataCache.ResetAll();
//                }
//                else
//                {
//                    MailSenderDataCache.SetCancelFlag();
//                }
//            }
//        }
//    }

//    [Serializable]
//    [DataContract]
//    public class MailTemplateTag
//    {
//        [DataMember(Name = "sysname")]
//        public String SysName { get; set; }

//        [DataMember(Name = "display_name")]
//        public String DisplayName { get; set; }

//        [DataMember(Name = "category")]
//        public String Category { get; set; }

//        [DataMember(Name = "is_company")]
//        public bool isCompany { get; set; }

//        [DataMember(Name = "name")]
//        public String Name { get; set; }
//    }

//    public class MailTemplateManager
//    {
//        private readonly Dictionary<String, IEnumerable<MailTemplateTag>> _templateTagsCache = new Dictionary<String, IEnumerable<MailTemplateTag>>();

//        private readonly DaoFactory _daoFactory;

//        public MailTemplateManager(DaoFactory daoFactory)
//        {
//            _daoFactory = daoFactory;
//        }

//        private IEnumerable<MailTemplateTag> GetTagsFrom(String template)
//        {
//            if (_templateTagsCache.ContainsKey(template)) return _templateTagsCache[template];

//            var tags = GetAllTags();

//            var result = new List<MailTemplateTag>();

//            var _regex = new Regex("\\$\\((Person|Company)\\.[^<>\\)]*\\)");


//            if (!_regex.IsMatch(template))
//                return new List<MailTemplateTag>();

//            foreach (Match match in _regex.Matches(template))
//            {
//                var findedTag = tags.Find(item => String.Compare(item.Name, match.Value) == 0);

//                if (findedTag == null) continue;

//                if (!result.Contains(findedTag))
//                    result.Add(findedTag);
//            }

//            _templateTagsCache.Add(template, result);

//            return result;
//        }

//        private String Apply(String template, IEnumerable<MailTemplateTag> templateTags, int contactID)
//        {
//            var result = template;


//            var contactDao = _daoFactory.GetContactDao();
//            var contactInfoDao = _daoFactory.GetContactInfoDao();
//            var customFieldDao = _daoFactory.GetCustomFieldDao();

//            var contact = contactDao.GetByID(contactID);

//            if (contact == null)
//                throw new ArgumentException(CRMErrorsResource.ContactNotFound);

//            foreach (var tag in templateTags)
//            {
//                var tagParts = tag.SysName.Split(new[] { '_' });

//                var source = tagParts[0];

//                var tagValue = String.Empty;

//                switch (source)
//                {
//                    case "common":

//                        if (contact is Person)
//                        {

//                            var person = (Person)contact;

//                            switch (tagParts[1])
//                            {

//                                case "firstName":
//                                    tagValue = person.FirstName;

//                                    break;
//                                case "lastName":
//                                    tagValue = person.LastName;

//                                    break;
//                                case "jobTitle":
//                                    tagValue = person.JobTitle;
//                                    break;
//                                case "companyName":
//                                    var relativeCompany = contactDao.GetByID(((Person)contact).CompanyID);

//                                    if (relativeCompany != null)
//                                        tagValue = relativeCompany.GetTitle();


//                                    break;
//                                default:
//                                    tagValue = String.Empty;
//                                    break;

//                            }

//                        }
//                        else
//                        {

//                            var company = (Company)contact;

//                            switch (tagParts[1])
//                            {
//                                case "companyName":
//                                    tagValue = company.CompanyName;
//                                    break;
//                                default:
//                                    tagValue = String.Empty;
//                                    break;
//                            }
//                        }

//                        break;
//                    case "customField":
//                        var tagID = Convert.ToInt32(tagParts[tagParts.Length - 1]);

//                        var entityType = contact is Company ? EntityType.Company : EntityType.Person;

//                        tagValue = customFieldDao.GetValue(entityType, contactID, tagID);

//                        break;
//                    case "contactInfo":
//                        var contactInfoType = (ContactInfoType)Enum.Parse(typeof(ContactInfoType), tagParts[1]);
//                        var category = Convert.ToInt32(tagParts[2]);
//                        var contactInfos = contactInfoDao.GetList(contactID, contactInfoType, category, true);

//                        if (contactInfos == null || contactInfos.Count == 0) break;

//                        var contactInfo = contactInfos[0];

//                        if (contactInfoType == ContactInfoType.Address)
//                        {
//                            var addressPart = (AddressPart)Enum.Parse(typeof(AddressPart), tagParts[3]);

//                            tagValue = JObject.Parse(contactInfo.Data)[addressPart.ToString().ToLower()].Value<String>();

//                        }
//                        else
//                            tagValue = contactInfo.Data;

//                        break;
//                    default:
//                        throw new ArgumentException(tag.SysName);
//                }

//                result = result.Replace(tag.Name, tagValue);
//            }

//            return result;
//        }

//        public String Apply(String template, int contactID)
//        {
//            return Apply(template, GetTagsFrom(template), contactID);
//        }

//        private String ToTagName(String value, bool isCompany)
//        {
//            return String.Format("$({0}.{1})", isCompany ? "Company" : "Person", value);
//        }

//        private List<MailTemplateTag> GetAllTags()
//        {
//            return GetTags(true).Union(GetTags(false)).ToList();
//        }

//        public List<MailTemplateTag> GetTags(bool isCompany)
//        {
//            var result = new List<MailTemplateTag>();

//            if (isCompany)
//            {

//                result.Add(new MailTemplateTag
//                {
//                    DisplayName = CRMContactResource.CompanyName,
//                    SysName = "common_companyName",
//                    Category = CRMContactResource.GeneralInformation,
//                    isCompany = isCompany,
//                    Name = ToTagName("Company Name", isCompany)
//                });

//            }
//            else
//            {
//                result.Add(new MailTemplateTag
//                {
//                    DisplayName = CRMContactResource.FirstName,
//                    SysName = "common_firstName",
//                    Category = CRMContactResource.GeneralInformation,
//                    isCompany = false,
//                    Name = ToTagName("First Name", isCompany)
//                });

//                result.Add(new MailTemplateTag
//                {
//                    DisplayName = CRMContactResource.LastName,
//                    SysName = "common_lastName",
//                    Category = CRMContactResource.GeneralInformation,
//                    isCompany = false,
//                    Name = ToTagName("Last Name", isCompany)
//                });

//                result.Add(new MailTemplateTag
//                {
//                    DisplayName = CRMContactResource.JobTitle,
//                    SysName = "common_jobTitle",
//                    Category = CRMContactResource.GeneralInformation,
//                    isCompany = false,
//                    Name = ToTagName("Job Title", isCompany)
//                });


//                result.Add(new MailTemplateTag
//                {
//                    DisplayName = CRMContactResource.CompanyName,
//                    SysName = "common_companyName",
//                    Category = CRMContactResource.GeneralInformation,
//                    isCompany = false,
//                    Name = ToTagName("Company Name", isCompany)
//                });

//            }

//            foreach (ContactInfoType infoTypeEnum in Enum.GetValues(typeof(ContactInfoType)))
//            {

//                var localName = String.Format("contactInfo_{0}_{1}", infoTypeEnum, ContactInfo.GetDefaultCategory(infoTypeEnum));
//                var localTitle = infoTypeEnum.ToLocalizedString();

//                if (infoTypeEnum == ContactInfoType.Address)
//                    foreach (AddressPart addressPartEnum in Enum.GetValues(typeof(AddressPart)))
//                        result.Add(new MailTemplateTag
//                        {
//                            SysName = String.Format(localName + "_{0}_{1}", addressPartEnum, (int)AddressCategory.Work),
//                            DisplayName = String.Format(localTitle + " {0}", addressPartEnum.ToLocalizedString()),
//                            Category = CRMContactResource.GeneralInformation,
//                            isCompany = isCompany,
//                            Name = ToTagName(String.Format("{0} {1}", infoTypeEnum.ToString(), addressPartEnum.ToString()), isCompany)
//                        });
//                else
//                    result.Add(new MailTemplateTag
//                    {
//                        SysName = localName,
//                        DisplayName = localTitle,
//                        Category = CRMContactResource.GeneralInformation,
//                        isCompany = isCompany,
//                        Name = ToTagName(infoTypeEnum.ToString(), isCompany)
//                    });
//            }

//            var entityType = isCompany ? EntityType.Company : EntityType.Person;

//            var customFieldsDao = _daoFactory.GetCustomFieldDao();

//            var customFields = customFieldsDao.GetFieldsDescription(entityType);

//            var category = CRMContactResource.GeneralInformation;

//            foreach (var customField in customFields)
//            {
//                if (customField.FieldType == CustomFieldType.SelectBox) continue;
//                if (customField.FieldType == CustomFieldType.CheckBox) continue;

//                if (customField.FieldType == CustomFieldType.Heading)
//                {
//                    if (!String.IsNullOrEmpty(customField.Label))
//                        category = customField.Label;

//                    continue;
//                }

//                result.Add(new MailTemplateTag
//                {
//                    SysName = "customField_" + customField.ID,
//                    DisplayName = customField.Label.HtmlEncode(),
//                    Category = category,
//                    isCompany = isCompany,
//                    Name = ToTagName(customField.Label, isCompany)
//                });
//            }

//            return result;
//        }

//    }
//}