/ThinkEmailFomatter/Models/BusinessObjects/ThinkHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ThinkEmailFormatter.ThinkOdata;
using System.Net;
using ThinkEmailFormatter.Models.Extensions.ThinkObj;
using System.Threading.Tasks;

namespace ThinkEmailFormatter.Models
{
    public class ThinkHelper: IThinkHelper
    {
        private ThinkModel _thinkModel;

        public ThinkHelper(ThinkModel thinkModel)
        {
            _thinkModel = thinkModel;
            _thinkModel.UsePostTunneling = true;
        }

        public Customer GetCustomerInfo(int customerId)
        {
            var customerLogin = _thinkModel.CustomerLogins
                .Where(c => c.customer_id == customerId)
                .Select(c => c)
                .FirstOrDefault();

            Customer customerDetails = new Customer() 
            {
                Username = customerLogin != null ? customerLogin.login : string.Empty 
            };

            return customerDetails;

        }

        /// <summary>
        /// Get all email template settings from the database
        /// </summary>
        /// <returns></returns>
        public List<TemplateSetting> GetAllTemplateSettings()
        {
            List<TemplateSetting> allTemplateSettings = new List<TemplateSetting>();

            var settings = _thinkModel.EmailTemplates.Select(s => s);

            foreach (var setting in settings)
            {
                TemplateSetting tempSetting = new TemplateSetting();
                tempSetting.CastFromThinkObj(setting);
                allTemplateSettings.Add(tempSetting);
            }

            return allTemplateSettings;
        }

        /// <summary>
        /// Get the template's settings from the THINK DB using the Think OData Service.
        /// Then convert the Dataobject into a "TemplateSetting" Domain Object
        /// </summary>
        /// <param name="templateName"></param>
        /// <returns></returns>
        public TemplateSetting GetTemplateSettings(string templateName)
        {
            TemplateSetting templateSettings = null;

            var templateThinkSettings = _thinkModel.EmailTemplates.Expand("TransactionEvent,EmailFilterOptions")
                .Where(t => t.name == templateName)
                .Select(t => t)
                .ToList();

            if (templateThinkSettings != null && templateThinkSettings.Any())
            {
                var templateThinkSetting = templateThinkSettings.First();

                templateSettings = new TemplateSetting();
                templateSettings.CastFromThinkObj(templateThinkSetting);
            }

            return templateSettings;
        }

        public bool CommitSettings(TemplateSetting templateSettings)
        {
            bool requestStatus = true;

            if (templateSettings != null)
            {
                // If the Guid is not empty, that means that this template has been configured in the past
                // The settings just need to be updated
                if (templateSettings.Guid != Guid.Empty)
                {
                    EmailTemplate existingSetting = new EmailTemplate()
                    {
                        email_template_id = templateSettings.Guid,
                        name = templateSettings.Name,
                        description = templateSettings.Description,
                        from_email = templateSettings.FromEmail,
                        transaction_event_id = (short)templateSettings.EventType.Id,
                        oc_id = templateSettings.OrderClass.Id,
                        enable_default = templateSettings.DefaultEnabled,
                        enable_tax_invoice_check = templateSettings.TaxInvoiceCheckEnabled,
                        subject = templateSettings.Subject
                    };

                    _thinkModel.AttachTo("EmailTemplates", existingSetting);
                    _thinkModel.UpdateObject(existingSetting);

                    if (templateSettings.Filters != null && templateSettings.Filters.Any())
                    {
                        foreach (var filter in templateSettings.Filters)
                        {
                            bool deleteFilter = string.Compare(filter.Description.Trim(), "delete", true) == 0;
                            bool skipCondition = 
                                (filter.Guid == Guid.Empty && deleteFilter) ||
                                    ((filter.OrderCode == null || filter.OrderCode.Id == 0) &&
                                    (filter.SourceCode == null || filter.SourceCode.Id == 0) &&
                                    (filter.SubscriptionDefinition == null || filter.SubscriptionDefinition.Id == 0));

                            // don't skip
                            if (!skipCondition)
                            {
                                EmailFilterOption filterOpt = new EmailFilterOption();
                                // new filter
                                if (filter.Guid == Guid.Empty)
                                {
                                    filterOpt.email_template_id = templateSettings.Guid;
                                    filterOpt.email_filter_id = Guid.NewGuid();
                                    filterOpt.active = filter.Active;
                                    if (filter.OrderCode != null && filter.OrderCode.Id != 0)
                                        filterOpt.order_code_id = filter.OrderCode.Id;
                                    if (filter.SourceCode != null && filter.SourceCode.Id != 0)
                                        filterOpt.source_code_id = filter.SourceCode.Id;
                                    if (filter.SubscriptionDefinition != null && filter.SubscriptionDefinition.Id != 0)
                                        filterOpt.subscription_def_id = filter.SubscriptionDefinition.Id;

                                    _thinkModel.AddToEmailFilterOptions(filterOpt);
                                }
                                else if(deleteFilter) // // existing filter. Need to delete it
                                {
                                    filterOpt.email_filter_id = filter.Guid;
                                    _thinkModel.AttachTo("EmailFilterOptions", filterOpt);
                                    _thinkModel.DeleteObject(filterOpt);
                                }
                                else // existing filter. Need to update it
                                {
                                    filterOpt.email_template_id = templateSettings.Guid;
                                    filterOpt.email_filter_id = filter.Guid;
                                    filterOpt.active = filter.Active;
                                    if (filter.OrderCode != null && filter.OrderCode.Id != 0)
                                        filterOpt.order_code_id = filter.OrderCode.Id;
                                    if (filter.SourceCode != null && filter.SourceCode.Id != 0)
                                        filterOpt.source_code_id = filter.SourceCode.Id;
                                    if (filter.SubscriptionDefinition != null && filter.SubscriptionDefinition.Id != 0)
                                        filterOpt.subscription_def_id = filter.SubscriptionDefinition.Id;

                                    _thinkModel.AttachTo("EmailFilterOptions", filterOpt);
                                    _thinkModel.UpdateObject(filterOpt);
                                }
                            }
                        }
                    }

                    _thinkModel.SaveChanges();
                }
                else // new template settings
                {
                    EmailTemplate newEmailTemplateSettings = new EmailTemplate()
                    {
                        email_template_id = Guid.NewGuid(),
                        name = templateSettings.Name,
                        description = templateSettings.Description,
                        from_email = templateSettings.FromEmail,
                        transaction_event_id = (short)templateSettings.EventType.Id,
                        oc_id = templateSettings.OrderClass.Id,
                        enable_default = templateSettings.DefaultEnabled,
                        enable_tax_invoice_check = templateSettings.TaxInvoiceCheckEnabled,
                        subject = templateSettings.Subject
                    };

                    _thinkModel.AddToEmailTemplates(newEmailTemplateSettings);

                    if (templateSettings.Filters != null && templateSettings.Filters.Any())
                    {
                        foreach (var filter in templateSettings.Filters)
                        {
                            bool skipCondition =
                                (filter.Guid == Guid.Empty && string.Compare(filter.Description.Trim(), "delete", true) == 0) ||
                                    ((filter.OrderCode == null || filter.OrderCode.Id == 0) &&
                                    (filter.SourceCode == null || filter.SourceCode.Id == 0) &&
                                    (filter.SubscriptionDefinition == null || filter.SubscriptionDefinition.Id == 0));

                            // don't skip
                            if (!skipCondition)
                            {
                                EmailFilterOption filterOpt = new EmailFilterOption();
                                // new filter
                                if (filter.Guid == Guid.Empty)
                                {
                                    filterOpt.email_template_id = templateSettings.Guid;
                                    filterOpt.email_filter_id = Guid.NewGuid();
                                    filterOpt.active = filter.Active;
                                    if (filter.OrderCode != null && filter.OrderCode.Id != 0)
                                        filterOpt.order_code_id = filter.OrderCode.Id;
                                    if (filter.SourceCode != null && filter.SourceCode.Id != 0)
                                        filterOpt.source_code_id = filter.SourceCode.Id;
                                    if (filter.SubscriptionDefinition != null && filter.SubscriptionDefinition.Id != 0)
                                        filterOpt.subscription_def_id = filter.SubscriptionDefinition.Id;

                                    _thinkModel.AddToEmailFilterOptions(filterOpt);
                                }
                            }
                        }
                    }

                    _thinkModel.SaveChanges();
                }
                
            }
            else
            {
                requestStatus = false;
            }

            return requestStatus;
        }

        public bool DeleteTemplateSettings(string templateName)
        {
            bool operationSuccess = true;

            try
            {
                var templateThinkSettings = _thinkModel.EmailTemplates.Expand("EmailFilterOptions")
                    .Where(t => t.name == templateName)
                    .Select(t => t)
                    .FirstOrDefault();

                if (templateThinkSettings != null)
                {
                    // delete all options related to that email template
                    if (templateThinkSettings.EmailFilterOptions != null && templateThinkSettings.EmailFilterOptions.Any())
                    {
                        foreach (var option in templateThinkSettings.EmailFilterOptions)
                        {
                            _thinkModel.DeleteObject(option);
                        }
                    }

                    // delete the email template
                    _thinkModel.DeleteObject(templateThinkSettings);

                    _thinkModel.SaveChanges();
                }
            }
            catch (Exception ie)
            {
                operationSuccess = false;
            }

            return operationSuccess;
        }

        /// <summary>
        /// Get all THINK transaction events
        /// </summary>
        /// <returns></returns>
        public List<Identifier> GetEventTypeList()
        {
            List<Identifier> eventTypes = null;

            var thinkEventTypes = _thinkModel.TransactionEvents.Select(e => e).ToList();

            if (thinkEventTypes != null && thinkEventTypes.Any())
            {
                eventTypes = new List<Identifier>();

                foreach(var thinkEventType in thinkEventTypes.OrderBy(e => e.transaction_name))
                {
                    eventTypes.Add(new Identifier()
                    {
                        Id = thinkEventType.transaction_event_id,
                        Name = thinkEventType.transaction_name,
                        Flag = thinkEventType.display_filter ?? false
                    });
                }
            }

            return eventTypes;
        }

        /// <summary>
        /// Get all THINK order classes(Table oc)
        /// </summary>
        /// <returns></returns>
        public List<Identifier> GetOrderClassList()
        {
            List<Identifier> orderClasses = null;

            var thinkOrderClasses = _thinkModel.OrderClasses.Select(o => o).ToList();

            if (thinkOrderClasses != null && thinkOrderClasses.Any())
            {
                orderClasses = new List<Identifier>() { new Identifier() { Id = 0, Name = "0: None" } };

                foreach (var thinkOrderClass in thinkOrderClasses.OrderBy(o => o.oc_id))
                {
                    orderClasses.Add(new Identifier()
                    {
                        Id = thinkOrderClass.oc_id,
                        Name = string.Format("{1}: {0}", thinkOrderClass.oc1, thinkOrderClass.oc_id)
                    });
                }
            }

            return orderClasses;
        }

        /// <summary>
        /// Get all email settings that have been configured in the DB and match the
        /// think request parameters
        /// </summary>
        /// <param name="thinkRequest"></param>
        /// <returns></returns>
        public List<TemplateSetting> GetMatchingEmailSettings(ThinkTransactionData thinkRequest)
        {
            List<TemplateSetting> emailSettings = null;

            int transactionEventId;
            Int32.TryParse(thinkRequest.transaction_event, out transactionEventId);
            
            var matchingEmailSettings = _thinkModel.EmailTemplates
                .Expand("EmailFilterOptions")
                .Where(e => e.transaction_event_id == transactionEventId)
                .Select(e => e)
                .ToList();

            if (matchingEmailSettings != null && matchingEmailSettings.Any())
            {
                emailSettings = new List<TemplateSetting>();

                foreach (var matchingSetting in matchingEmailSettings)
                {
                    TemplateSetting templateSettings = new TemplateSetting();
                    templateSettings.CastFromThinkObj(matchingSetting);

                    emailSettings.Add(templateSettings);
                }
            }

            return emailSettings;
        }

        public int GetMatchingOrderClass(int orderCode)
        {
            return _thinkModel.OrderCodes.Where(o => o.order_code_id == orderCode).Select(o => o.oc_id).First();
        }
    }
}