Send scheduled Reminder/Alerts by email in SharePoint

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Mullivan.SharePoint.Reminders;
using Mullivan.Collections.Generic;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.Utilities;
using System.Collections.Generic;
using System.Xml.Xsl;

namespace Mullivan.SharePoint.Pages
{
    public partial class _EditReminderSettings : Microsoft.SharePoint.WebControls.LayoutsPageBase
    {
        private List<RmdConfiguration> _rmdConfigs;
        private SPWeb _spWeb = null;
        private SPList _spList = null;
        private SPBaseType _baseType;
        private SPListTemplateType _templateType;
        private string _strDefaultViewUrl;
        private RmdConfiguration _rmdCurrent;

        // Properties
        protected override SPBasePermissions RightsRequired
        {
            get
            {
                return (SPBasePermissions.EmptyMask | SPBasePermissions.ManageLists);
            }
        }

        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);

            ddlType.Items.Add(new ListItem(RmdType.Item.ToString()));
            ddlType.Items.Add(new ListItem(RmdType.Bulk.ToString()));

            ddlRecurrence.Items.Add(new ListItem("Hourly"));
            ddlRecurrence.Items.Add(new ListItem("Daily"));
            ddlRecurrence.Items.Add(new ListItem("Weekly"));
            ddlRecurrence.Items.Add(new ListItem("Monthly"));

            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Sunday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Monday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Tuesday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Wednesday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Thursday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Friday.ToString()));
            ddlDayOfWeek.Items.Add(new ListItem(DayOfWeek.Saturday.ToString()));

            SetControlVisibility(rvDay, false);
            SetControlVisibility(rvHour, false);
            SetControlVisibility(rvMinute, false);
            SetControlVisibility(rfvName, false);
            SetControlVisibility(rfvMailTo, false);
            SetControlVisibility(rfvSubject, false);
            SetControlVisibility(rfvXslTransform, false);

            ddlRecurrence.SelectedIndexChanged += new EventHandler(ddlRecurrence_SelectedIndexChanged);
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            ThrowIfNoListQueryString();
            ThrowIfNoReminderQueryString();
            
            _spWeb = SPControl.GetContextWeb(HttpContext.Current);
            _spList = _spWeb.Lists.GetList(new Guid(this.Request.QueryString.GetValues("List")[0]), true);
            _rmdConfigs = RmdUtil.GetRmdConfigs(_spList);
            if (_rmdConfigs == null)
                _rmdConfigs = new List<RmdConfiguration>();

            _baseType = this._spList.BaseType;
            _templateType = this._spList.BaseTemplate;
            _strDefaultViewUrl = this._spList.DefaultViewUrl;
            if (_templateType == SPListTemplateType.UserInformation)
            {
                if (!(base.Web.ServerRelativeUrl == "/"))
                    _strDefaultViewUrl = base.Web.ServerRelativeUrl + "/_layouts/people.aspx";
                else
                    _strDefaultViewUrl = base.Web.ServerRelativeUrl + "_layouts/people.aspx";
            }

            string rmdVal = this.Request.QueryString["Reminder"];
            try
            {
                Guid g = new Guid(rmdVal);
                foreach (RmdConfiguration config in _rmdConfigs)
                {
                    if (g == config.Id)
                        _rmdCurrent = config;
                }
            }
            catch { }

            if (_rmdCurrent == null)
            {
                _rmdCurrent = new RmdConfiguration();
                _rmdConfigs.Add(_rmdCurrent);
            }

            if (!Page.IsPostBack)
            {
                LoadViews();
                LoadSettings();
            }

            base.PageTarget = this._spList;
            this.onetidListEditTitleLink.NavigateUrl = SPHttpUtility.UrlPathEncode(this._strDefaultViewUrl, true);
            this.onetidListEditTitleLink.Text = SPHttpUtility.HtmlEncode(this._spList.Title);

        }

        private void LoadViews()
        {
            ddlFillViewFields.Items.Clear();
            ddlFillQuery.Items.Clear();
            foreach (SPView view in _spList.Views)
            {
                ddlFillViewFields.Items.Add(new ListItem(view.Title, view.ID.ToString()));
                ddlFillQuery.Items.Add(new ListItem(view.Title, view.ID.ToString()));
           
            }
            if (ddlFillViewFields.Items.Count > 0)
            {
                ddlFillViewFields.SelectedIndex = 0;
                ddlFillQuery.SelectedIndex = 0;
            }
        }

        private void LoadSettings()
        {
            tboxName.Text = _rmdCurrent.DisplayName;
            tboxMailTo.Text = string.Empty;
            if (_rmdCurrent.MailTo != null)
            {
                foreach (string mailTo in _rmdCurrent.MailTo)
                    tboxMailTo.Text += mailTo + "; ";
            }
            tboxQuery.Text = _rmdCurrent.Query;
            tboxSubject.Text = _rmdCurrent.Subject;
            tboxXslTransform.Text = _rmdCurrent.XslTransform;
            cboxSendNoResult.Checked = _rmdCurrent.SendNoResults;
            ddlType.SelectedValue = _rmdCurrent.Type.ToString();
            tboxViewFields.Text = _rmdCurrent.ViewFields;

            if (_rmdCurrent.Recurrence != null)
                ddlRecurrence.SelectedValue = _rmdCurrent.Recurrence.Name;
            else
                ddlRecurrence.SelectedIndex = 0;

            SetRecurrenceControls();
        }

        private void ddlRecurrence_SelectedIndexChanged(object sender, EventArgs e)
        {
            _rmdCurrent.Recurrence = null;
            SetRecurrenceControls();
        }

        private void SetRecurrenceControls()
        {
            if (_rmdCurrent.Recurrence == null)
            {
                switch (ddlRecurrence.SelectedValue)
                {
                    case "Hourly":
                        _rmdCurrent.Recurrence = new RmdHourlyRecurrence();
                        break;
                    case "Daily":
                        _rmdCurrent.Recurrence = new RmdDailyRecurrence();
                        break;
                    case "Weekly":
                        _rmdCurrent.Recurrence = new RmdWeeklyRecurrence();
                        break;
                    case "Monthly":
                        _rmdCurrent.Recurrence = new RmdMonthlyRecurrence();
                        break;
                }
            }

            switch (ddlRecurrence.SelectedValue)
            {
                case "Hourly":
                    SetControlVisibility(tboxMinute, true);
                    SetControlVisibility(lblStartMinute, true);
                    SetControlVisibility(tboxDay, false);
                    SetControlVisibility(lblStartDay, false);
                    SetControlVisibility(tboxHour, false);
                    SetControlVisibility(lblStartHour, false);
                    SetControlVisibility(ddlDayOfWeek, false);
                    SetControlVisibility(lblDayOfWeek, false);

                    tboxMinute.Text = ((RmdHourlyRecurrence)_rmdCurrent.Recurrence).StartMinute.ToString();
                    break;
                case "Daily":
                    SetControlVisibility(tboxMinute, false);
                    SetControlVisibility(lblStartMinute, false);
                    SetControlVisibility(tboxHour, true);
                    SetControlVisibility(lblStartHour, true);
                    SetControlVisibility(tboxDay, false);
                    SetControlVisibility(lblStartDay, false);
                    SetControlVisibility(ddlDayOfWeek, false);
                    SetControlVisibility(lblDayOfWeek, false);

                    tboxHour.Text = ((RmdDailyRecurrence)_rmdCurrent.Recurrence).StartHour.ToString();
                    break;
                case "Weekly":
                    SetControlVisibility(tboxMinute, false);
                    SetControlVisibility(lblStartMinute, false);
                    SetControlVisibility(tboxHour, true);
                    SetControlVisibility(lblStartHour, true);
                    SetControlVisibility(tboxDay, false);
                    SetControlVisibility(lblStartDay, false);
                    SetControlVisibility(ddlDayOfWeek, true);
                    SetControlVisibility(lblDayOfWeek, true);

                    tboxHour.Text = ((RmdWeeklyRecurrence)_rmdCurrent.Recurrence).StartHour.ToString();
                    ddlDayOfWeek.SelectedValue = ((RmdWeeklyRecurrence)_rmdCurrent.Recurrence).DayOfWeek.ToString();
                    break;
                case "Monthly":
                    SetControlVisibility(tboxMinute, false);
                    SetControlVisibility(lblStartMinute, false);
                    SetControlVisibility(tboxHour, true);
                    SetControlVisibility(lblStartHour, true);
                    SetControlVisibility(tboxDay, true);
                    SetControlVisibility(lblStartDay, true);
                    SetControlVisibility(ddlDayOfWeek, false);
                    SetControlVisibility(lblDayOfWeek, false);

                    tboxHour.Text = ((RmdMonthlyRecurrence)_rmdCurrent.Recurrence).StartHour.ToString();
                    tboxDay.Text = ((RmdMonthlyRecurrence)_rmdCurrent.Recurrence).StartDay.ToString();
                    break;
            }
        }

        private void SetControlVisibility(WebControl ctrl, bool visible)
        {
            if (!visible)
            {
                ctrl.Visible = false;
                ctrl.Style[HtmlTextWriterStyle.Display] = "none";
            }
            else
            {
                ctrl.Visible = true;
                ctrl.Style[HtmlTextWriterStyle.Display] = "inline";
            }
        }

        private bool SaveSettings()
        {
            rfvName.Validate();
            if (!rfvName.IsValid)
            {
                SetControlVisibility(rfvName, true);
                return false;
            }
            rfvSubject.Validate();
            if (!rfvSubject.IsValid)
            {
                SetControlVisibility(rfvSubject, true);
                return false;
            }
            rfvXslTransform.Validate();
            if (!rfvXslTransform.IsValid)
            {
                SetControlVisibility(rfvXslTransform, true);
                return false;
            }

            switch (ddlRecurrence.SelectedValue)
            {
                case "Hourly":
                    rvMinute.Validate();
                    if (!rvMinute.IsValid)
                    {
                        SetControlVisibility(rvMinute, true);
                        return false;
                    }

                    RmdHourlyRecurrence rHourly = new RmdHourlyRecurrence();
                    _rmdCurrent.Recurrence = rHourly;
                    if (!string.IsNullOrEmpty(tboxMinute.Text))
                        rHourly.StartMinute = int.Parse(tboxMinute.Text);
                    else
                        rHourly.StartMinute = 1;
                    break;
                case "Daily":
                    rvHour.Validate();
                    if (!rvHour.IsValid)
                    {
                        SetControlVisibility(rvHour, true);
                        return false;
                    }

                    RmdDailyRecurrence rDaily = new RmdDailyRecurrence();
                    _rmdCurrent.Recurrence = rDaily;
                    if (!string.IsNullOrEmpty(tboxHour.Text))
                        rDaily.StartHour = int.Parse(tboxHour.Text);
                    else
                        rDaily.StartHour = 0;
                    break;
                case "Weekly":
                    rvHour.Validate();
                    if (!rvHour.IsValid)
                    {
                        SetControlVisibility(rvHour, true);
                        return false;
                    }

                    RmdWeeklyRecurrence rWeekly = new RmdWeeklyRecurrence();
                    _rmdCurrent.Recurrence = rWeekly;
                    if (!string.IsNullOrEmpty(tboxHour.Text))
                        rWeekly.StartHour = int.Parse(tboxHour.Text);
                    else
                        rWeekly.StartHour = 0;
                    rWeekly.DayOfWeek = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), ddlDayOfWeek.SelectedValue);
                    break;
                case "Monthly":
                    rvHour.Validate();
                    if (!rvHour.IsValid)
                    {
                        SetControlVisibility(rvHour, true);
                        return false;
                    }
                    rvDay.Validate();
                    if (!rvDay.IsValid)
                    {
                        SetControlVisibility(rvDay, true);
                        return false;
                    }
                    RmdMonthlyRecurrence rMontly = new RmdMonthlyRecurrence();
                    _rmdCurrent.Recurrence = rMontly;
                    if (!string.IsNullOrEmpty(tboxHour.Text))
                        rMontly.StartHour = int.Parse(tboxHour.Text);
                    else
                        rMontly.StartHour = 0;
                    if (!string.IsNullOrEmpty(tboxDay.Text))
                        rMontly.StartDay = int.Parse(tboxDay.Text);
                    else
                        rMontly.StartDay = 1;
                    break;
            }

            _rmdCurrent.DisplayName = tboxName.Text;
            _rmdCurrent.Query = tboxQuery.Text;
            _rmdCurrent.Subject = tboxSubject.Text;
            _rmdCurrent.XslTransform = tboxXslTransform.Text;
            _rmdCurrent.SendNoResults = cboxSendNoResult.Checked;
            _rmdCurrent.ViewFields = tboxViewFields.Text;
            _rmdCurrent.Type = (RmdType)Enum.Parse(typeof(RmdType), ddlType.SelectedValue);
            if (tboxMailTo.Text.Trim() != string.Empty)
            {
                List<string> liMailTo = new List<string>(tboxMailTo.Text.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries));
                for (int i = 0; i < liMailTo.Count; i++)
                {
                    liMailTo[i] = liMailTo[i].Trim();
                    if (string.IsNullOrEmpty(liMailTo[i]))
                    {
                        liMailTo.RemoveAt(i);
                        i--;
                    }
                }
                if (liMailTo.Count > 0)
                    _rmdCurrent.MailTo = liMailTo.ToArray();
                else
                    _rmdCurrent.MailTo = null;
            }
            else
                _rmdCurrent.MailTo = null;

            if (_rmdCurrent.MailTo == null || _rmdCurrent.MailTo.Length < 1)
            {
                tboxMailTo.Text = string.Empty;
                rfvMailTo.Validate();
                if (!rfvMailTo.IsValid)
                {
                    SetControlVisibility(rfvMailTo, true);
                    return false;
                }
            }

            RmdUtil.SetRmdConfigs(this._spList, _rmdConfigs);
            return true;
        }

        protected void btnFillViewFields_Click(object sender, EventArgs e)
        {
            try
            {
                if (string.IsNullOrEmpty(ddlFillViewFields.SelectedValue))
                    return;
                Guid viewId = new Guid(ddlFillViewFields.SelectedValue);
                SPView view = _spList.Views[viewId];

                if (view == null)
                    return;

                tboxViewFields.Text = view.ViewFields.SchemaXml;
            }
            catch { }
        }

        protected void btnFillQuery_Click(object sender, EventArgs e)
        {
            try
            {
                if (string.IsNullOrEmpty(ddlFillQuery.SelectedValue))
                    return;
                Guid viewId = new Guid(ddlFillQuery.SelectedValue);
                SPView view = _spList.Views[viewId];

                if (view == null)
                    return;

                tboxQuery.Text = view.Query;
                
            }
            catch { }
        }

        protected void btnCancel_Click(object sender, EventArgs e)
        {
            string url = string.Format("~{0}/_layouts/ReminderSettings.aspx?List={1}",
                base.Web.ServerRelativeUrl, this._spList.ID);
            Response.Redirect(url);
        }

        protected void btnOK_Click(object sender, EventArgs e)
        {

            if (!SaveSettings())
                return;

            string url = string.Format("~{0}/_layouts/ReminderSettings.aspx?List={1}",
                base.Web.ServerRelativeUrl, this._spList.ID);
            Response.Redirect(url);
        }

        protected void btnTest_Click(object sender, EventArgs e)
        {
            try
            {
                string strHtml = string.Empty;
                string strXml = string.Empty;
                XsltArgumentList argList = null;

                SPListItemCollection spItems = RmdUtil.ExecuteQuery(this._spList, this.tboxQuery.Text, this.tboxViewFields.Text);

                if (spItems.Count > 0)
                {
                    argList = RmdUtil.GetXsltArgList(_spList);

                    if (ddlType.SelectedValue.Equals("Bulk"))
                        strXml = RmdUtil.GetXml(spItems);
                    else
                    {
                        if (spItems.Count > 0)
                            strXml = RmdUtil.GetXml(spItems[0]);
                    }

                    if (!string.IsNullOrEmpty(this.tboxXslTransform.Text.Trim()))
                        strHtml = RmdUtil.RenderHtml(strXml, argList, this.tboxXslTransform.Text);
                    else
                        strHtml = HttpUtility.HtmlEncode(strXml).Replace("\n", "<br/>");
                }

                litTest.Text = strHtml;
            }
            catch (Exception ex)
            {
                litTest.Text = HttpUtility.HtmlEncode(ex.ToString()).Replace("\n", "<br/>");
            }
        }

        public static void ThrowIfNoListQueryString()
        {
            string[] values = HttpContext.Current.Request.QueryString.GetValues("List");
            if ((values == null) || (values.Length == 0))
            {
                throw new SPException(SPResource.GetString("InvalidQueryString", new object[] { "List" }));
            }
        }

        public static void ThrowIfNoReminderQueryString()
        {
            string[] values = HttpContext.Current.Request.QueryString.GetValues("Reminder");
            if ((values == null) || (values.Length == 0))
            {
                throw new SPException("Invalid query string. Reminder value is missing.");
            }
        }
    }
}