Calendar.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Sage.O365Management.Classes.OData;
using System.Web.Script.Serialization;
using sage.ew.usuario;
using System.Data;
using sage.ew.db;
using sage.ew.global;

namespace sage.ew.o365
{
    public class CalendarClass : o365consumer//, ICalendarClass
    {
        #region Public properties

        public string _Name
        {
            get { return _cName; }
            set { _cName = value; }
        }
        private string _cName = "";

        public CalendarColor _Color
        {
            get { return _oColor; }
            set { _oColor = value; }
        }
        private CalendarColor _oColor = CalendarColor.Auto;

        public Dictionary<string, string> _AvailableCalendars
        {
            get
            {
                //Si me han cambiado el usuario a partir del que se montó el diccionario... lo resteo
                if (!String.IsNullOrWhiteSpace(_Sage50User) && (_Sage50User != _CurrentUserCode)) //Si he utizado algún usuario y ahora ha cambiado...
                {
                    _dicCalendariosUsuario = null;
                }



                if (_dicCalendariosUsuario == null)
                {
                    if (!String.IsNullOrWhiteSpace(_UserCalendars))
                    {
                        //Try to get stored user calendars
                        Dictionary<string, string> ldicCalendarios = new JavaScriptSerializer().Deserialize<Dictionary<string, string>>(_UserCalendars);
                        if (ldicCalendarios != null && ldicCalendarios.Count > 0) _dicCalendariosUsuario = ldicCalendarios;
                        else
                        {
                            UpdateCalendarList();
                        }
                    }
                    else _GetCalendars();
                }

                return _dicCalendariosUsuario;

            }
            set { _dicCalendariosUsuario = value; }
        }
        private Dictionary<string, string> _dicCalendariosUsuario = null;

        public string _RegisteredSharedEmail
        {
            get { return _SharedEmail; }
        }

        public string _RegisteredSharedCalendar
        {
            get { return _SharedCalendarId; }
        }

        public bool _RegisteredShareCalendar
        {
            get { return _SharedCalendarActive; }
            set 
            { 
                if(_SharedCalendarActive != value)
                    _SharedCalendarActive = value; 
            }
        }

        #endregion Public properties

        #region Private properties

        private Calendars _Calendars
        {
            get { return _oCalendars; }
            set
            {
                _oCalendars = value;
                _dicCalendariosUsuario = _Montar_Diccionario();
                UpdateCalendarList(); //Save the updated calendar list
            }
        }
        private Calendars _oCalendars = null;

        private Calendar _Calendar
        {
            get { return _oCalendar; }
            set { _oCalendar = value; }
        }
        private Calendar _oCalendar = null;

        //PE-97427 Rollback shared calendar operations
        bool    _OldSharedCalendarActive = false;
        string _OldSharedCalendarId = "";
        string _OldSharedEmail = "";
        string _OldSharedRefreshToken = "";
        string _OldSharedServiceResourceIds = "";

        #endregion Private properties

        #region Constructors

        public CalendarClass() 
        {
            _GetSharedBackupData(); //PE-97427 
        }

        public CalendarClass(bool tlRegisterMode) 
        {
            //Set the registration mode
            _lRegisterMode = tlRegisterMode;

            _GetSharedBackupData(); //PE-97427 
        }

        #endregion Constructors

        #region Public Methods

        public bool _New()
        {
            bool llOk = true;
            Calendar loCalendar = new Calendar();
            loCalendar.Name = _Name;
            loCalendar.Color = _Color;
            try
            {
                //check if exists
                Calendars loCals = (Calendars)O365Management.GetCalendars();
                bool llExists = false;
                foreach (Calendar loCalItem in loCals.Data)
                {
                    //Search previous existing calendar
                    if (loCalItem.Name.Contains("Calendario " + Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"))))
                    {
                        llExists = true;
                        _Calendar = loCalItem;
                        break;
                    }
                }

                if(!llExists)
                    _Calendar = (Calendar)O365Management.CreateCalendar(_Name);

                //Update calendar lists
                llOk = (_Calendar != null);
                if (llOk && _lRegisterMode) //Register mode
                {
                    Sage.O365Management.Classes.OData.AccountInfo loAccount = (Sage.O365Management.Classes.OData.AccountInfo)O365Management.GetAccountInfo();

                    //Register the calendar as Shared calendar 
                    _SharedCalendarId = _Calendar.Id;
                    _SharedEmail = loAccount.Id;
                    _SharedRefreshToken = O365Management.RefreshToken;
                    _SharedServiceResourceIds = new JavaScriptSerializer().Serialize(O365Management.ServiceResourceIds);
                    OSharedCalendarData._Save();
                }

                return llOk;
            }
            catch (Exception loException)
            {
                _RaiseException(loException);
            }

            return llOk;
        }

        internal bool _RegisterSharedCalendar()
        {
            if (!_lRegisterMode) return false;

            bool llOk = true;
            Calendar loCalendar = new Calendar();
            loCalendar.Name = _Name;
            loCalendar.Color = _Color;
            try
            {
                //To ensure use new manager
                _ResetOManagers();

                //check if exists
                Calendars loCals = (Calendars)O365ManagementSage50.GetCalendars();
                bool llExists = false;
                foreach (Calendar loCalItem in loCals.Data)
                {
                    //Search previous existing calendar
                    if (loCalItem.Name.Contains("Calendario " + Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"))))
                    {
                        llExists = true;
                        _Calendar = loCalItem;
                        break;
                    }
                }

                if (!llExists)
                    _Calendar = (Calendar)O365ManagementSage50.CreateCalendar(_Name);

                //Update calendar lists
                llOk = (_Calendar != null);
                if (llOk && _lRegisterMode) //Register mode
                {
                    Sage.O365Management.Classes.OData.AccountInfo loAccount = (Sage.O365Management.Classes.OData.AccountInfo)O365ManagementSage50.GetAccountInfo();

                    //Register the calendar as Shared calendar 
                    _SharedCalendarId = _Calendar.Id;
                    _SharedEmail = loAccount.Id;
                    _SharedRefreshToken = O365ManagementSage50.RefreshToken;
                    _SharedServiceResourceIds = new JavaScriptSerializer().Serialize(O365ManagementSage50.ServiceResourceIds);
                    OSharedCalendarData._Save();

                    //To ensure no one have invalid Shared CalendarIds stored in BBDD
                    _ResetUserStoredCalendars();
                    //_UserCalendars = "";
                }

                return llOk;
            }
            catch (Exception loException)
            {
                _RaiseException(loException);
            }

            return llOk;
        }

        #region Rollback Shared Calendar

        //PE-97427 Rollback shared calendar operations

        //PE-97427
        private void _GetSharedBackupData()
        {
            _OldSharedCalendarActive = _SharedCalendarActive;
            _OldSharedCalendarId = _SharedCalendarId;
            _OldSharedEmail = _SharedEmail;
            _OldSharedRefreshToken = _SharedRefreshToken;
            _OldSharedServiceResourceIds = _SharedServiceResourceIds;
        }

        //PE-97427
        internal void _RestoreSharedBackupData()
        {
            //Restore the initial values
            _SharedCalendarActive = _OldSharedCalendarActive;
            _SharedCalendarId = _OldSharedCalendarId;
            _SharedEmail = _OldSharedEmail;
            _SharedRefreshToken = _OldSharedRefreshToken;
            _SharedServiceResourceIds = _OldSharedServiceResourceIds;
            OSharedCalendarData._Save();
        }

        #endregion Rollback Shared Calendar

        internal bool _UnregisterSharedCalendar()
        {
            bool llOk = false;

            //Only in registration mode for defined calendar use
            if (!_lRegisterMode || !_IsSharingCalendar) return false;

            _SharedCalendarId = "";
            _SharedEmail = "";
            _SharedRefreshToken = "";
            _SharedServiceResourceIds = "";
            llOk = OSharedCalendarData._Save();

            //Fuerzo un logout
            _ResetOManagers();

            //To ensure no one have invalid Shared CalendarIds stored in BBDD
            _ResetUserStoredCalendars();

            return llOk;
        }

        public bool _Delete(string tcIdCalendar)
        {
            //Pending
            return O365Management.DeleteCalendar(tcIdCalendar);
        }

        public bool _Add(Appointment toAppointment, string tcIdCalendar = "")
        {
            bool llOk = true;

            try
            {
                return ((Appointment)toAppointment)._New(tcIdCalendar); ;
            }
            catch (Exception loException)
            {
                _RaiseException(loException);
                llOk = false;
            }

            return llOk;
        }

        public bool _Add(Meeting toMeeting, string tcIdCalendar = "")
        {
            bool llOk = true;

            try
            {
                return toMeeting._New(tcIdCalendar);
            }
            catch (Exception loException)
            {
                _RaiseException(loException);
                llOk = false;
            }

            return llOk;
        }

        public void _GetCalendar(string tcIdCalendar = "")
        {
            try
            {
                _oCalendar = (Calendar)O365Management.GetCalendar(tcIdCalendar);
            }
            catch (Exception loEx)
            {
                _RaiseException(loEx);
                _ErrorMessage = loEx.Message;
            }
        }


        public void UpdateCalendarList()
        {
            _UserCalendars = new JavaScriptSerializer().Serialize(_dicCalendariosUsuario);
            Usuario._This._Save();
        }

        public Dictionary<string, string> _GetCalendars()
        {

            try
            {
                _Calendars = (Calendars)O365Management.GetCalendars(); //During the SET operation of _Calendars the dicctionary is updated
                return _dicCalendariosUsuario;
            }
            catch (Exception loEx)
            {
                _RaiseException(loEx);
            }

            //Void return
            return new Dictionary<string, string>();
        }

        #endregion Public Methods

        #region Private Methods

        //PE-99934
        void _This__Evento_UsuarioCambiado(object sender, EventArgs e)
        {
            _dicCalendariosUsuario = null;
        }

        private Events _GetEvents(string tcIdCalendar)
        {
            Events loEvents = new Events();

            try //PE-97495 To catch credential missing exception
            {
                loEvents = (Events)O365Management.GetEvents(tcIdCalendar);
            }
            catch (Exception loException)
            {
                _RaiseException(loException);
            }

            return loEvents;
        }

        public DataTable _GetEvents(string tcIdCalendar, string tcPattern, bool tlLiteral = false)
        {
            //Check if is a shared operation
            CheckForSharedCalendarOperation(tcIdCalendar);
            
            DataTable ldtEventos = new DataTable();

            //Define the structure of the result DataTable
            ldtEventos.Columns.Add("Subject", typeof(string));
            ldtEventos.Columns.Add("Start", typeof(DateTime));
            ldtEventos.Columns.Add("End", typeof(DateTime));
            ldtEventos.Columns.Add("Id", typeof(string));

            Events loEvents = _GetEvents(tcIdCalendar);
            //PE-97495 If no events or exception raised return empty table
            if (loEvents.Data == null) return ldtEventos;

            foreach (Event loEvent in loEvents.Data)
            {
                TimeZoneInfo timeZone = TimeZoneInfo.FindSystemTimeZoneById(loEvent.Start.TimeZone);

                DataRow ldrNewRow = ldtEventos.NewRow();
                ldrNewRow["Subject"] = loEvent.Subject;
                //PE-97378 Local time vs UTC
                if (loEvent.IsAllDay == true) //API limation, time is UTC dont be shown as local time
                {
                    ldrNewRow["Start"] = Convert.ToDateTime(loEvent.Start.DateTime); //DateTime no, ha que usar hora local
                    ldrNewRow["End"] = Convert.ToDateTime(loEvent.End.DateTime).AddMinutes(-1);
                }
                else //Local Time
                {
                    ldrNewRow["Start"] = TimeZoneInfo.ConvertTime(Convert.ToDateTime(loEvent.Start.DateTime), timeZone, TimeZoneInfo.Local);
                    ldrNewRow["End"] = TimeZoneInfo.ConvertTime(Convert.ToDateTime(loEvent.End.DateTime), timeZone, TimeZoneInfo.Local);
                    //ldrNewRow["Start"] = Convert.ToDateTime(loEvent.Start.DateTime); //DateTime no, ha que usar hora local
                    //ldrNewRow["End"] = Convert.ToDateTime(loEvent.End.DateTime);
                }

                ldrNewRow["Id"] = loEvent.Id;

                //PE-97317 filtro fecha superior a la actual
                DateTime endEvent = TimeZoneInfo.ConvertTime(Convert.ToDateTime(loEvent.End.DateTime), timeZone, TimeZoneInfo.Local);
                if (DateTime.Compare(endEvent, DateTime.Now) > 0)
                    ldtEventos.Rows.Add(ldrNewRow);
            }

            //PE-97317 Ordeno por fecha
            ldtEventos.DefaultView.Sort = "Start ASC, End ASC";
            ldtEventos = ldtEventos.DefaultView.ToTable();

            //get filter strings
            if (!String.IsNullOrWhiteSpace(tcPattern))
            {
                string lcFilterString = "";
                if (tlLiteral)
                {
                    char[] laDelimiterChars = { '[', ']'};
                    string[] laWords = tcPattern.Split(laDelimiterChars,StringSplitOptions.RemoveEmptyEntries);
                    lcFilterString = laWords[0];
                    ldtEventos.DefaultView.RowFilter = "Subject like '[[]" + lcFilterString + "[]]%'";
                }
                else
                {
                    lcFilterString = _GetFilterString(tcPattern);
                    ldtEventos.DefaultView.RowFilter = "Subject like '" + lcFilterString.Replace("[", "[[]") + "%'";
                }
                return ldtEventos.DefaultView.ToTable();
            }

            return ldtEventos;
        }

        private void CheckForSharedCalendarOperation(string tcIdCalendar)
        {
            //Check for Shared operation
            _UseSharedCalendar = (_RegisteredSharedCalendar == tcIdCalendar);
        }

        public string _GetFilterString(string tcPantalla)
        {
            bool llOk = false;
            string lcSql = "";
            DataTable ldtResult = new DataTable();
            string lcFilterString = "";

            // Preparamos la consulta
            lcSql = "SELECT pantalla, valor FROM " + 
                DB.SQLDatabase("comunes", "calendar") +
                " WHERE pantalla = " + DB.SQLString(tcPantalla.Trim().ToUpper());

            llOk = DB.SQLExec(lcSql, ref ldtResult);
            if (llOk && ldtResult != null && ldtResult.Rows.Count > 0)
            {
                string lcValue = Convert.ToString(ldtResult.Rows[0]["valor"]).Trim();
                string [] laKeyParts = lcValue.Split(':');
                if (laKeyParts.Count() > 1) //Is the correct spliter
                {
                    lcFilterString = laKeyParts[0];
                }
                else //Not all items contains : => then use ]
                {
                    laKeyParts = lcValue.Split(']');
                    if (laKeyParts.Count() > 1) //Is the correct spliter
                    {
                        lcFilterString = laKeyParts[0];
                    }
                    else lcFilterString = ""; //Unknown splitter 
                }
            }

            return lcFilterString;
        }



        private Dictionary<string, string> _Montar_Diccionario()
        {
            //Dictionary<string, string> loDic = new Dictionary<string, string>();
            SortedDictionary<string, string> loDic = new SortedDictionary<string, string>();
            foreach (Calendar loCalendar in _Calendars.Data)
            {
                //Skip shared calendar to avoid unsual operations
                if (loCalendar.Id == _SharedCalendarId || loCalendar.Name.Contains("Calendario " + Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto")))) continue; 
                //Skip special calendars
                //PE- Se detectan casos de Días y días en los calendarios que crea Outlook y dado que la función Contains no admite cfg CaseInsensitive borramos la primera letra
                if (loCalendar.Name.Contains("Cumpleaños") || loCalendar.Name.Contains("ías festivos de")) continue; 
                loDic.Add(loCalendar.Name, loCalendar.Id);
            }
            
            //Add Shared calendar
            if(_IsSharingCalendar)
                loDic.Add("Calendario " + Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto")), _SharedCalendarId);

            return new Dictionary<string, string>(loDic); //Convert to common dicctionary
        }

        #endregion Private Methods
    }
}