Open Source Extensible Enterprise n-tier Application Framework with Multilayered Architecture

using System;
using SiberTek.Xenta.Data;
using SiberTek.Xenta.Data.Providers;
using SiberTek.Xenta.Entities;
using SiberTek.Xenta.Entities.Collections;
using SiberTek.Xenta.Events;
using SiberTek.Xenta.Exceptions;
using SiberTek.Xenta.Utils;
using SiberTek.Xenta.Enums;
using SiberTek.Xenta.Config;

namespace SiberTek.Xenta.Managers
{
    /// <summary>
    /// Contains methods to manage polls and poll answers
    /// </summary>
    public class PollManager : IManager
    {
        #region Fields
        private static PollManager _instance = null;
        private IPollDataProvider _pollDataProvider;
        private IPollAnswerDataProvider _answerDataProvider;
        private bool _initialized;
        #endregion

        #region Constructors
        private PollManager()
        {
            _pollDataProvider = null;
            _answerDataProvider = null;
            _initialized = false;
        }
        #endregion

        #region Events
        public event EntityEventHandler PollCreated;
        public event EntityEventHandler PollUpdated;
        public event EntityEventHandler PollDeleted;
        public event EntityEventHandler PollAnswerCreated;
        public event EntityEventHandler PollAnswerUpdated;
        public event EntityEventHandler PollAnswerDeleted;
        #endregion

        #region Properties
        public static PollManager Instance
        {
            get
            {
                if(_instance == null)
                {
                    _instance = new PollManager();
                }
                return _instance;
            }
        }

        private IPollDataProvider PollDataProvider
        {
            get
            {
                return _pollDataProvider;
            }
        }

        private IPollAnswerDataProvider AnswerDataProvider
        {
            get
            {
                return _answerDataProvider;
            }
        }
        #endregion

        #region Methods
        public void Initialize()
        {
            if(!_initialized)
            {
                _pollDataProvider = DataAccessManager.GetProviderInstance<IPollDataProvider>("PollDataProvider");
                _answerDataProvider = DataAccessManager.GetProviderInstance<IPollAnswerDataProvider>("PollAnswerDataProvider");

                LanguageManager.Instance.LanguageDeleted += OnLanguageDeleted;

                _initialized = true;
            }
        }

        public PollInfo CreatePoll(int languageID, string title, DateTime startDate, DateTime endDate, bool isActive)
        {
            if(LanguageManager.Instance.GetLanguage(languageID) == null)
            {
                throw new XentaException("Language does not exist", (int)CoreError.LanguageDoesNotExist);
            }

            PollInfo poll = null;
            int pollID;
            title = StringHelper.TrimToLength(title, 100);

            if(PollDataProvider.InsertPoll(languageID, title, startDate, endDate, isActive, DateTime.UtcNow, DateTime.UtcNow, out pollID))
            {
                poll = GetPoll(pollID);
                FirePollCreated(poll);
            }
            return poll;
        }

        public PollAnswerInfo CreatePollAnswer(int pollID, string title, int count, int displayOrder)
        {
            if(GetPoll(pollID) == null)
            {
                throw new XentaException("Poll does not exist", (int)ContentError.PollDoesNotExist);
            }

            PollAnswerInfo answer = null;
            int answerID;
            title = StringHelper.TrimToLength(title, 100);

            if(AnswerDataProvider.InsertPollAnswer(pollID, title, count, displayOrder, DateTime.UtcNow, DateTime.UtcNow, out answerID))
            {
                answer = GetPollAnswer(answerID);
                FirePollAnswerCreated(answer);
            }
            return answer;
        }

        public PollInfo GetPoll(int pollID)
        {
            return DataMapper.Map(PollDataProvider.GetPoll(pollID));
        }

        public PollInfoCollection GetPollsByLanguageID(int languageID)
        {
            return GetPollsByLanguageID(languageID, false);
        }

        public PollInfoCollection GetPollsByLanguageID(int languageID, bool showHidden)
        {
            return GetAllPolls(languageID, null, null, null, null, showHidden);
        }

        public PollInfoCollection GetAllPolls(int? languageID, DateTime? startDate, DateTime? endDate, DateTime? createdOnStart, DateTime? createdOnEnd, bool showHidden)
        {
            return DataMapper.Map(PollDataProvider.GetAllPolls(languageID, startDate, endDate, createdOnStart, createdOnEnd, showHidden));
        }

        public PollAnswerInfo GetPollAnswer(int answerID)
        {
            return DataMapper.Map(AnswerDataProvider.GetPollAnswer(answerID));
        }

        public PollAnswerInfoCollection GetPollAnswersByPollID(int pollID)
        {
            return DataMapper.Map(AnswerDataProvider.GetPollAnswersByPollID(pollID));
        }

        public PollInfo UpdatePoll(int pollID, int languageID, string title, DateTime startDate, DateTime endDate, bool isActive)
        {
            if(LanguageManager.Instance.GetLanguage(languageID) == null)
            {
                throw new XentaException("Language does not exist", (int)CoreError.LanguageDoesNotExist);
            }

            PollInfo poll = GetPoll(pollID);
            if(poll == null)
            {
                throw new XentaException("Poll does not exist", (int)ContentError.PollDoesNotExist);
            }

            title = StringHelper.TrimToLength(title, 100);

            if(PollDataProvider.UpdatePoll(pollID, languageID, title, startDate, endDate, isActive, poll.CreatedOn, DateTime.UtcNow))
            {
                poll = GetPoll(pollID);
                FirePollUpdated(poll);
            }
            return poll;
        }

        public PollAnswerInfo UpdatePollAnswer(int answerID, int pollID, string title, int count, int displayOrder)
        {
            PollAnswerInfo answer = GetPollAnswer(answerID);
            if(answer == null)
            {
                throw new XentaException("Poll answer does not exist", (int)ContentError.PollAnswerDoesNotExist);
            }
            if(answer.PollID != pollID && GetPoll(pollID) == null)
            {
                throw new XentaException("Poll does not exist", (int)ContentError.PollDoesNotExist);
            }

            title = StringHelper.TrimToLength(title, 100);

            if(AnswerDataProvider.UpdatePollAnswer(answerID, pollID, title, count, displayOrder, answer.CreatedOn, DateTime.UtcNow))
            {
                answer = GetPollAnswer(answerID);
                FirePollAnswerUpdated(answer);
            }
            return answer;
        }

        public void DeletePoll(int pollID)
        {
            PollInfo poll = GetPoll(pollID);

            if(poll != null)
            {
                FirePollDeleted(poll);
                foreach(PollAnswerInfo answer in GetPollAnswersByPollID(pollID))
                {
                    DeletePollAnswer(answer.AnswerID);
                }
                PollDataProvider.DeletePoll(pollID);
            }
        }

        public void DeletePollAnswer(int answerID)
        {
            PollAnswerInfo answer = GetPollAnswer(answerID);

            if(answer != null)
            {
                FirePollAnswerDeleted(answer);
                AnswerDataProvider.DeletePollAnswer(answerID);
            }
        }
        #endregion

        #region Handlers
        private void OnLanguageDeleted(object sender, EntityEventArgs e)
        {
            LanguageInfo language = e.Entity as LanguageInfo;

            if(language != null)
            {
                foreach(PollInfo poll in GetPollsByLanguageID(language.LanguageID))
                {
                    DeletePoll(poll.PollID);
                }
            }
        }
        #endregion

        #region Utilties
        private void FirePollCreated(PollInfo poll)
        {
            if(PollCreated != null)
            {
                PollCreated(this, new EntityEventArgs(poll));
            }
        }

        private void FirePollUpdated(PollInfo poll)
        {
            if(PollUpdated != null)
            {
                PollUpdated(this, new EntityEventArgs(poll));
            }
        }

        private void FirePollDeleted(PollInfo poll)
        {
            if(PollDeleted != null)
            {
                PollDeleted(this, new EntityEventArgs(poll));
            }
        }

        private void FirePollAnswerCreated(PollAnswerInfo pollAnswer)
        {
            if(PollAnswerCreated != null)
            {
                PollAnswerCreated(this, new EntityEventArgs(pollAnswer));
            }
        }

        private void FirePollAnswerUpdated(PollAnswerInfo pollAnswer)
        {
            if(PollAnswerUpdated != null)
            {
                PollAnswerUpdated(this, new EntityEventArgs(pollAnswer));
            }
        }

        private void FirePollAnswerDeleted(PollAnswerInfo pollAnswer)
        {
            if(PollAnswerDeleted != null)
            {
                PollAnswerDeleted(this, new EntityEventArgs(pollAnswer));
            }
        }
        #endregion
    }
}