void PullDues()
        {
            Dispatcher.BeginInvoke(delegate
            {
                progressIndicator.IsVisible = true;
            });
            try
            {
                Task.Run(new Action(() =>
                {
                    calendarModel = CalendarMobile.GetCalendarEvents(SettingsMobile.Instance.User.MemberId, SettingsMobile.Instance.User.LoginId, SettingsMobile.Instance.AccountSettings.CalendarId, CalendarOwnerEntityEnum.league, DateTime.UtcNow.Year, DateTime.UtcNow.Month);

                    Dispatcher.BeginInvoke(delegate
                    {
                        EventList.ItemsSource = calendarModel.Events;
                        progressIndicator.IsVisible = false;
                    });

                }));

            }
            catch (Exception exception)
            {
                ErrorHandler.Save(exception, MobileTypeEnum.WP8);
            }
        }
        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            try
            {

                calendarModel = new Portable.Classes.Controls.Calendar.Calendar();

                //(App.Current as App).SecondPageObject = null;
                progressIndicator = SystemTray.ProgressIndicator;
                progressIndicator = new ProgressIndicator();
                SystemTray.SetProgressIndicator(this, progressIndicator);
                progressIndicator.IsIndeterminate = true;
                progressIndicator.Text = "Pulling Events...";
                if (SettingsMobile.Instance.User == null)
                {
                    SqlFactory fact = new SqlFactory();
                    SettingsMobile.Instance.User = fact.GetProfile();
                }
                if (SettingsMobile.Instance.AccountSettings.IsEventsCoordinatorOrBetter)
                {
                    ApplicationBar.IsVisible = true;
                }
                PullDues();

            }
            catch (Exception exception)
            {
                ErrorHandler.Save(exception, MobileTypeEnum.WP8);
            }



        }
        public ActionResult LoadCalendarView(string lid, string startDt, string endDt)
        {
            Calendar cal = new Calendar();

            try
            {
                cal.CalendarId = new Guid();

                if (new Guid(lid) != new Guid())
                {
                    DateTime st = DateTimeExt.FromUnixTime(Convert.ToInt64(startDt));
                    DateTime en = DateTimeExt.FromUnixTime(Convert.ToInt64(endDt));
                    var topics = CalendarFactory.GetPublicCalendarOfLeagueScheduleForView(new Guid(lid), st, en);
                    return Json(new { events = topics }, JsonRequestBehavior.AllowGet);
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }

            return Json(new { view = "" }, JsonRequestBehavior.AllowGet);
        }
        public ActionResult CreateCalendar(string OwnerEntity)
        {

            Calendar cal = new Calendar();
            try
            {
                Guid memberId = RDN.Library.Classes.Account.User.GetMemberId();
                if (OwnerEntity == CalendarOwnerEntityEnum.league.ToString())
                {
                    Guid ownerId = MemberCache.GetLeagueIdOfMember(memberId);
                    cal = CalendarFactory.CreateCalendar(ownerId, CalendarOwnerEntityEnum.league);
                }
                else if (OwnerEntity == CalendarOwnerEntityEnum.federation.ToString())
                {
                    Guid ownerId = MemberCache.GetFederationIdOfMember(memberId);
                    cal = CalendarFactory.CreateCalendar(ownerId, CalendarOwnerEntityEnum.federation);
                }

                MemberCache.Clear(memberId);
                MemberCache.ClearApiCache(memberId);
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return Redirect(Url.Content("~/calendar/" + OwnerEntity + "/" + cal.CalendarId.ToString().Replace("-", "")));
        }
        public ActionResult CalendarSettings(Calendar calendar)
        {
            try
            {
                CalendarFactory.UpdateCalendarSettings(calendar);
                var calen = CalendarFactory.GetCalendar(calendar.CalendarId, calendar.OwnerEntity);
                ViewBag.IsSuccessful = true;
                if (calen == null)
                    return Redirect(Url.Content("~/calendar/" + calendar.OwnerEntity.ToString() + "/" + calendar.CalendarId.ToString().Replace("-", "")));

                return View(calen);
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return View(calendar);
        }
 public ActionResult CalendarView(string type, string id)
 {
     Calendar cal = new Calendar();
     Guid memberId = RDN.Library.Classes.Account.User.GetMemberId();
     bool isAttendanceManagerOrBetter = MemberCache.IsAttendanceManagerOrBetterOfLeague(memberId);
     CalendarMessages(Request.Url.Query);
     try
     {
         cal.CalendarId = new Guid();
         cal.OwnerEntity = (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type);
         if (new Guid(id) != new Guid())
         {
             var topics = CalendarFactory.GetCalendarSchedule(new Guid(id), (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type), DateTime.Today.AddDays(-2), DateTime.Today.AddDays(31), memberId, isAttendanceManagerOrBetter);
             if (!topics.IsCalendarInUTC)
             {
                 SiteMessage message = new SiteMessage();
                 message.MessageType = SiteMessageType.Info;
                 message.Message = "Please set the TimeZone of your calendar in Settings.";
                 this.AddMessage(message);
             }
             topics.Events.AddRange(MemberCache.GetMemberBirthdays(memberId, DateTime.UtcNow.AddDays(-2), DateTime.UtcNow.AddDays(31)));
             topics.Events.AddRange(MemberCache.GetMemberStartDates(memberId, DateTime.UtcNow.AddDays(-2), DateTime.UtcNow.AddDays(31)));
             return View(topics);
         }
         else
         {
             return Redirect(Url.Content("~/calendar/league/" + id));
         }
     }
     catch (Exception exception)
     {
         ErrorDatabaseManager.AddException(exception, exception.GetType());
     }
     return View(cal);
 }
        public ActionResult LoadCalendarView(string type, string id, string startDt, string endDt)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar cal = new Calendar();
            Guid memberId = RDN.Library.Classes.Account.User.GetMemberId();
            CalendarMessages(Request.Url.Query);
            try
            {
                cal.CalendarId = new Guid();
                cal.OwnerEntity = (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type);
                if (new Guid(id) != new Guid())
                {
                    DateTime st = DateTimeExt.FromUnixTime(Convert.ToInt64(startDt));
                    DateTime en = DateTimeExt.FromUnixTime(Convert.ToInt64(endDt));
                    var topics = CalendarFactory.GetCalendarScheduleForView(new Guid(id), (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type), st, en, memberId);
                    if (!topics.DisableBirthdays)
                        topics.EventsJson.AddRange(MemberCache.GetMemberBirthdaysJson(memberId, st, en));
                    if (!topics.DisableSkatingStartDates)
                        topics.EventsJson.AddRange(MemberCache.GetMemberStartDatesJson(memberId, st, en));
                    return Json(new { events = topics.EventsJson }, JsonRequestBehavior.AllowGet);
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }

            return Json(new { view = "" }, JsonRequestBehavior.AllowGet);
        }
        public ActionResult CalendarList(string type, string id, int? year, int? month)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar cal = new RDN.Portable.Classes.Controls.Calendar.Calendar();
            try
            {
                Guid memberId = RDN.Library.Classes.Account.User.GetMemberId();
                bool isAttendanceManagerOrBetter = MemberCache.IsAttendanceManagerOrBetterOfLeague(memberId);
                var league = MemberCache.GetLeagueOfMember(memberId);
                if (league != null)
                    SetCulture(league.CultureSelected);
                CalendarMessages(Request.Url.Query);

                cal.CalendarId = new Guid();
                cal.OwnerEntity = (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type);
                if (year != null && month != null)
                    cal.CurrentDateSelected = new DateTime(year.Value, month.Value, 15);
                else
                    cal.CurrentDateSelected = DateTime.Now;
                if (new Guid(id) != new Guid())
                {
                    var topics = CalendarFactory.GetCalendarSchedule(new Guid(id), (CalendarOwnerEntityEnum)Enum.Parse(typeof(CalendarOwnerEntityEnum), type), DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-2), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(2), memberId, isAttendanceManagerOrBetter);

                    if (!topics.IsCalendarInUTC)
                    {
                        SiteMessage message = new SiteMessage();
                        message.MessageType = SiteMessageType.Info;
                        message.Message = "Please set the TimeZone of your calendar in Settings.";
                        this.AddMessage(message);
                    }

                    topics.CurrentDateSelected = cal.CurrentDateSelected;
                    if (!topics.DisableBirthdays)
                        topics.Events.AddRange(MemberCache.GetMemberBirthdays(memberId, DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-1), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(1)));
                    if (!topics.DisableSkatingStartDates)
                        topics.Events.AddRange(MemberCache.GetMemberStartDates(memberId, DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-1), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(1)));
                    return View(topics);
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return View(cal);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// any changes made here need to be mirrored in getcalendarscheduleForView
        /// </summary>
        /// <param name="id"></param>
        /// <param name="ownerEntity"></param>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public static RDN.Portable.Classes.Controls.Calendar.Calendar GetCalendarSchedule(Guid id, CalendarOwnerEntityEnum ownerEntity, DateTime startDate, DateTime endDate, Guid memberId, bool isAttendanceManagerOrBetter)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar newCal = new RDN.Portable.Classes.Controls.Calendar.Calendar();
            try
            {
                var dc = new ManagementContext();
                var calDb = (from xx in dc.Calendar.Include("CalendarEventsReocurring").Include("CalendarEvents").Include("CalendarEvents.ReocurringEvent").Include("CalendarEvents.PointsForEvent")
                             where xx.CalendarId == id
                             select new
                             {
                                 xx.IsCalendarInUTC,
                                 xx.TimeZone,
                                 Events = xx.CalendarEvents.Where(x => x.StartDate >= startDate && x.EndDate <= endDate && x.IsRemovedFromCalendar == false),
                                 FedOwners = xx.FederationOwners,
                                 LeagueOwners = xx.LeagueOwners,
                                 AllowSelfCheckIn = xx.AllowSelfCheckIn,
                                 xx.DisableBirthdaysFromShowing,
                                 xx.DisableStartSkatingDays,
                                 EventsReocurring = xx.CalendarEventsReocurring.Where(x => (x.EndReocurring >= startDate || x.EndReocurring == null) && x.StartReocurring <= endDate && x.IsRemovedFromCalendar == false),
                             }).FirstOrDefault();
                newCal.IsCalendarInUTC = calDb.IsCalendarInUTC;
                newCal.TimeZone = calDb.TimeZone;
                newCal.CalendarId = id;
                newCal.OwnerEntity = ownerEntity;
                newCal.AllowSelfCheckIn = calDb.AllowSelfCheckIn;
                newCal.DisableBirthdays = calDb.DisableBirthdaysFromShowing;
                newCal.DisableSkatingStartDates = calDb.DisableStartSkatingDays;
                if (ownerEntity == CalendarOwnerEntityEnum.federation)
                {
                    foreach (var own in calDb.FedOwners)
                    {
                        CalendarOwner owner = new CalendarOwner();
                        owner.OwnerId = own.Federation.FederationId;
                        owner.OwnerName = own.Federation.Name;
                        newCal.EntityName = own.Federation.Name;

                        newCal.Owners.Add(owner);
                    }
                }
                else if (ownerEntity == CalendarOwnerEntityEnum.league)
                {
                    foreach (var own in calDb.LeagueOwners)
                    {
                        CalendarOwner owner = new CalendarOwner();
                        owner.OwnerId = own.League.LeagueId;
                        owner.OwnerName = own.League.Name;
                        newCal.EntityName = own.League.Name;
                        newCal.Owners.Add(owner);
                    }
                }

                foreach (var ev in calDb.Events)
                {
                    newCal.Events.Add(CalendarEventFactory.DisplayEvent(ev, memberId, isAttendanceManagerOrBetter));
                }
                foreach (var ev in calDb.EventsReocurring)
                {
                    //used so we can refresh the last day events were created..

                    // ev.LastDateEventsWereCreated = endDate.AddMonths(-1);
                    if (ev.LastDateEventsWereCreated.GetValueOrDefault() < endDate)
                    {
                        var eventRe = dc.CalendarEventsReocurring.Where(x => x.CalendarItemId == ev.CalendarItemId && x.IsRemovedFromCalendar == false).FirstOrDefault();
                        eventRe.LastDateEventsWereCreated = endDate;
                        eventRe.Calendar = eventRe.Calendar;
                        dc.SaveChanges();

                        var aEvent = new CalendarViewEventJson()
                        {
                            id = ev.CalendarItemId,
                            Title = ev.Name,
                            Frequency = ev.FrequencyReocurring,
                            DaysOfWeek = ev.DaysOfWeekReocurring,
                            MonthlyInterval = ev.MonthlyIntervalReocurring
                        };
                        var schedule = new Schedule(aEvent);

                        var range = new DateRange()
                        {
                            StartDateTime = ev.StartReocurring
                        };
                        //date is null if the event is never ending.
                        if (ev.EndReocurring.HasValue)
                            range.EndDateTime = ev.EndReocurring.Value;
                        else
                            range.EndDateTime = endDate.AddMonths(1);

                        foreach (var date in schedule.Occurrences(range))
                        {
                            CalendarEvent calEvent = new CalendarEvent();
                            Guid locationId = new Guid();
                            if (ev.Location != null)
                            {
                                calEvent.Location.LocationName = ev.Location.LocationName;
                                locationId = ev.Location.LocationId;
                            }
                            calEvent.Name = ev.Name;
                            calEvent.CalendarItemId = ev.CalendarItemId;
                            if (eventRe.Color != null)
                            {
                                var c = Color.FromArgb(eventRe.Color.ColorIdCSharp);
                                calEvent.ColorTempSelected = ColorTranslator.ToHtml(c);
                            }

                            if (!ev.IsInUTCTime)
                            {
                                calEvent.StartDate = new DateTime(date.Year, date.Month, date.Day, ev.StartDate.Hour, ev.StartDate.Minute, ev.StartDate.Second);
                                calEvent.EndDate = new DateTime(date.Year, date.Month, date.Day, ev.EndDate.Hour, ev.EndDate.Minute, ev.EndDate.Second);
                            }
                            else
                            {
                                //we have to create a temp dates so we can add the timezone information without going back a day
                                //if the time being used is on the border.
                                //without the tempdates 1/4/2013 7pm turned into 1/3/2013 7pm because the timezones didn't account for the 
                                //fact the dates were already in utc.
                                var startTempDate = new DateTime(date.Year, date.Month, date.Day, ev.StartDate.Hour, ev.StartDate.Minute, ev.StartDate.Second) + new TimeSpan(ev.Calendar.TimeZone, 0, 0);
                                var endTempDate = new DateTime(date.Year, date.Month, date.Day, ev.EndDate.Hour, ev.EndDate.Minute, ev.EndDate.Second) + new TimeSpan(ev.Calendar.TimeZone, 0, 0);
                                calEvent.StartDate = new DateTime(date.Year, date.Month, date.Day, startTempDate.Hour, startTempDate.Minute, startTempDate.Second);
                                calEvent.EndDate = new DateTime(date.Year, date.Month, date.Day, endTempDate.Hour, endTempDate.Minute, endTempDate.Second);
                            }

                            calEvent.Notes = ev.Notes;
                            calEvent.AllowSelfCheckIn = ev.AllowSelfCheckIn;

                            //var evs = (from xx in newCal.Events
                            //           where xx.CalendarReoccurringId == ev.CalendarItemId
                            //           where xx.StartDate == calEvent.StartDate
                            //           where xx.EndDate == calEvent.EndDate
                            //           select xx).FirstOrDefault();
                            ////dirty bit to check if event was already in list.  If it is, we don't add it.
                            ////the date check here is to only create events within the calendar selected dates
                            //if (evs == null && calEvent.StartDate >= startDate && calEvent.EndDate <= endDate)
                            //{
                            //    string colorHex = String.Empty;
                            //    if (ev.Color != null)
                            //    {
                            //        var c = Color.FromArgb(ev.Color.ColorIdCSharp);
                            //        colorHex = ColorTranslator.ToHtml(c);
                            //    }
                            //    Guid calItemId = CalendarEventFactory.CreateNewEvent(ev.Calendar.CalendarId, calEvent.StartDate, calEvent.EndDate, locationId, ev.Name, ev.Link, ev.Notes, ev.AllowSelfCheckIn, ev.IsPublic, true, calEvent.CalendarItemId, ev.EventType.CalendarEventTypeId, false, ev.TicketUrl, colorHex, new List<long>(), memberId);
                            //    calEvent.CalendarItemId = calItemId;
                            //    newCal.Events.Add(calEvent);
                            //}
                        }

                    }
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return newCal;
        }
Ejemplo n.º 10
0
        public static RDN.Portable.Classes.Controls.Calendar.Calendar GetCalendar(Guid id, CalendarOwnerEntityEnum ownerEntity)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar newCal = new RDN.Portable.Classes.Controls.Calendar.Calendar();
            try
            {
                var dc = new ManagementContext();
                var calDb = (from xx in dc.Calendar
                             where xx.CalendarId == id
                             select new
                             {
                                 xx.CalendarId,
                                 xx.AllowSelfCheckIn,
                                 xx.NotPresentCheckIn,
                                 xx.DisableBirthdaysFromShowing,
                                 xx.DisableStartSkatingDays,
                                 xx.ImportFeedUrl,
                                 xx.CalendarImportTypeEnum,
                                 xx.TimeZone,
                                 xx.TimeZoneSelection,
                                 xx.IsCalendarInUTC
                             }).FirstOrDefault();

                if (calDb == null)
                    return null;

                newCal.CalendarId = id;
                newCal.OwnerEntity = ownerEntity;
                newCal.AllowSelfCheckIn = calDb.AllowSelfCheckIn;
                newCal.NotPresentCheckIn = calDb.NotPresentCheckIn;
                newCal.DisableSkatingStartDates = calDb.DisableStartSkatingDays;
                newCal.DisableBirthdays = calDb.DisableBirthdaysFromShowing;
                newCal.ImportFeedType = (CalendarImportTypeEnum)calDb.CalendarImportTypeEnum;
                newCal.ImportFeedUrl = calDb.ImportFeedUrl;
                if (calDb.TimeZoneSelection != null)
                    newCal.TimeZoneId = calDb.TimeZoneSelection.ZoneId;
                newCal.TimeZone = (int)calDb.TimeZone;

                newCal.TimeZones = Classes.Location.TimeZoneFactory.GetTimeZones();

                newCal.IsCalendarInUTC = calDb.IsCalendarInUTC;

                var types = dc.CalendarEventTypes.Where(x => x.CalendarOwner.CalendarId == id);
                foreach (var type in types)
                {
                    CalendarEventType t = new CalendarEventType();
                    t.CalendarEventTypeId = type.CalendarEventTypeId;
                    t.EventTypeName = type.EventTypeName;
                    t.PointsForExcused = type.PointsForExcused;
                    t.PointsForNotPresent = type.PointsForNotPresent;
                    t.PointsForPartial = type.PointsForPartial;
                    t.PointsForPresent = type.PointsForPresent;
                    t.PointsForTardy = type.PointsForTardy;
                    if (type.DefaultColor != null)
                    {
                        var c = Color.FromArgb(type.DefaultColor.ColorIdCSharp);
                        t.ColorTempSelected = ColorTranslator.ToHtml(c);
                        t.ColorName = type.DefaultColor.ColorName;
                    }
                    newCal.EventTypes.Add(t);
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return newCal;
        }
Ejemplo n.º 11
0
        public static RDN.Portable.Classes.Controls.Calendar.Calendar CreateCalendar(Guid ownerId, CalendarOwnerEntityEnum ownerType)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar calNew = new RDN.Portable.Classes.Controls.Calendar.Calendar();
            try
            {
                var dc = new ManagementContext();
                DataModels.Calendar.Calendar cal = new DataModels.Calendar.Calendar();
                cal.AllowSelfCheckIn = false;
                cal.IsCalendarInUTC = true;
                if (ownerType == CalendarOwnerEntityEnum.federation)
                {
                    DataModels.Calendar.CalendarFederationOwnership owner = new DataModels.Calendar.CalendarFederationOwnership();
                    owner.Calendar = cal;
                    owner.Federation = dc.Federations.Where(x => x.FederationId == ownerId).FirstOrDefault();
                    owner.OwnerType = Convert.ToInt32(CalendarOwnerTypeEnum.Owner);
                    cal.FederationOwners.Add(owner);
                }
                else if (ownerType == CalendarOwnerEntityEnum.league)
                {
                    DataModels.Calendar.CalendarLeagueOwnership owner = new DataModels.Calendar.CalendarLeagueOwnership();
                    owner.Calendar = cal;
                    owner.League = dc.Leagues.Where(x => x.LeagueId == ownerId).FirstOrDefault();
                    owner.OwnerType = Convert.ToInt32(CalendarOwnerTypeEnum.Owner);
                    cal.LeagueOwners.Add(owner);
                }
                else if (ownerType == CalendarOwnerEntityEnum.member)
                {
                    DataModels.Calendar.CalendarMemberOwnership owner = new DataModels.Calendar.CalendarMemberOwnership();
                    owner.Calendar = cal;
                    owner.Member = dc.Members.Where(x => x.MemberId == ownerId).FirstOrDefault();
                    owner.OwnerType = Convert.ToInt32(CalendarOwnerTypeEnum.Owner);
                    cal.MemberOwners.Add(owner);
                }
                dc.Calendar.Add(cal);
                dc.SaveChanges();

                calNew.CalendarId = cal.CalendarId;
                calNew.OwnerEntity = ownerType;
                calNew.AllowSelfCheckIn = false;
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return calNew;
        }
Ejemplo n.º 12
0
        /// <summary>
        /// any changes made here need to be mirrored in getcalendarschedule
        /// </summary>
        /// <param name="id"></param>
        /// <param name="ownerEntity"></param>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public static RDN.Portable.Classes.Controls.Calendar.Calendar GetCalendarScheduleForView(Guid id, CalendarOwnerEntityEnum ownerEntity, DateTime startDate, DateTime endDate, Guid memberId)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar cal = new RDN.Portable.Classes.Controls.Calendar.Calendar();

            try
            {
                var dc = new ManagementContext();
                var calDb = (from xx in dc.Calendar.Include("CalendarEventsReocurring").Include("CalendarEvents").Include("CalendarEvents.ReocurringEvent").Include("CalendarEvents.PointsForEvent")
                             where xx.CalendarId == id
                             select new
                             {
                                 xx.IsCalendarInUTC,
                                 xx.TimeZone,
                                 xx.TimeZoneSelection,
                                 xx.DisableStartSkatingDays,
                                 xx.DisableBirthdaysFromShowing,
                                 Events = xx.CalendarEvents.Where(x => x.StartDate >= startDate && x.EndDate <= endDate && x.IsRemovedFromCalendar == false),
                                 EventsReocurring = xx.CalendarEventsReocurring.Where(x => (x.EndReocurring >= startDate || x.EndReocurring == null) && x.StartReocurring <= endDate && x.IsRemovedFromCalendar == false),
                             }).FirstOrDefault();

                string baseUrl = VirtualPathUtility.ToAbsolute("~/calendar/event/" + ownerEntity.ToString() + "/" + id.ToString().Replace("-", "") + "/");
                cal.DisableSkatingStartDates = calDb.DisableStartSkatingDays;
                cal.DisableBirthdays = calDb.DisableBirthdaysFromShowing;
                //adds all the events from the database that were in the date range selected.
                foreach (var ev in calDb.Events)
                {
                    try
                    {
                        CalendarEventJson calEvent = new CalendarEventJson();
                        if (ev.Color != null)
                        {
                            var c = Color.FromArgb(ev.Color.ColorIdCSharp);
                            calEvent.backColor = ColorTranslator.ToHtml(c);
                        }
                        calEvent.title = ev.Name;
                        //removes length less than 14 chars 
                        //because the title is too long for the calendar display.
                        if (ev.Name.Length > 14)
                            calEvent.title = calEvent.title.Remove(14);
                        calEvent.id = ev.CalendarItemId;
                        if (ev.ReocurringEvent != null)
                            calEvent.ReocurringId = ev.ReocurringEvent.CalendarItemId;
                        calEvent.url = baseUrl + ev.CalendarItemId.ToString().Replace("-", "");
                        if (!ev.IsInUTCTime)
                        {
                            calEvent.start = ev.StartDate.ToString("o");
                            calEvent.end = ev.EndDate.ToString("o");
                            calEvent.StartDate = ev.StartDate;
                            calEvent.EndDate = ev.EndDate;
                        }
                        else
                        {
                            calEvent.StartDate = ev.StartDate + new TimeSpan(calDb.TimeZone, 0, 0);
                            calEvent.EndDate = ev.EndDate + new TimeSpan(calDb.TimeZone, 0, 0);
                            if (calEvent.StartDate != null)
                                calEvent.start = calEvent.StartDate.ToString("o");
                            if (calEvent.EndDate != null)
                                calEvent.end = calEvent.EndDate.ToString("o");
                        }
                        cal.EventsJson.Add(calEvent);
                    }
                    catch (Exception exception)
                    {
                        ErrorDatabaseManager.AddException(exception, exception.GetType(), additionalInformation: calDb.TimeZone + ":" + ev.StartDate + ":" + ev.EndDate);
                    }
                }
                
                int amount = dc.SaveChanges();
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return cal;
        }
Ejemplo n.º 13
0
        public static RDN.Portable.Classes.Controls.Calendar.Calendar GetCalendarEvents(Guid id, int count, Guid currentMemberId, bool isAttendanceManagerOrBetter)
        {
            RDN.Portable.Classes.Controls.Calendar.Calendar newCal = new RDN.Portable.Classes.Controls.Calendar.Calendar();
            try
            {
                var dc = new ManagementContext();
                var events = dc.CalendarEvents.Where(x => x.Calendar.CalendarId == id && x.StartDate >= DateTime.UtcNow && x.IsRemovedFromCalendar == false).OrderBy(x => x.StartDate).Take(count).AsParallel().ToList();

                newCal.CalendarId = id;

                foreach (var ev in events)
                {
                    newCal.Events.Add(CalendarEventFactory.DisplayEvent(ev, currentMemberId, isAttendanceManagerOrBetter));
                }
                if (newCal.Events.Count > 0)
                {
                    TimeSpan ts = newCal.Events.OrderBy(x => x.StartDate).FirstOrDefault().StartDate - DateTime.UtcNow;
                    newCal.DaysToNextEvent = ts.Days;
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return newCal;
        }
        public ActionResult CalendarList()
        {

            Calendar cal = new Calendar();
            try
            {
                if (HttpContext.Request.InputStream != null)
                {
                    Stream stream = HttpContext.Request.InputStream;
                    var ob = Network.LoadObject<CalendarSendParams>(ref stream);
                    var mem = MemberCache.GetMemberDisplay(ob.CurrentMemberId);
                    if (ob.UserId == mem.UserId)
                    {

                        var league = MemberCache.GetLeagueOfMember(ob.CurrentMemberId);
                        var isAttendanceManagerOrBetter = MemberCache.IsAttendanceManagerOrBetterOfLeague(ob.CurrentMemberId);
                        cal.CurrentDateSelected = new DateTime(ob.Year, ob.Month, 15);

                        cal = CalendarFactory.GetCalendarSchedule(ob.CalendarId, ob.CalendarType, DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-1), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(1), ob.CurrentMemberId, isAttendanceManagerOrBetter);

                        cal.CurrentDateSelected = new DateTime(ob.Year, ob.Month, 15);
                        if (!cal.DisableBirthdays)
                            cal.Events.AddRange(MemberCache.GetMemberBirthdays(ob.CurrentMemberId, DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-1), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(1)));
                        if (!cal.DisableSkatingStartDates)
                            cal.Events.AddRange(MemberCache.GetMemberStartDates(ob.CurrentMemberId, DateTimeExt.FirstDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(-1), DateTimeExt.LastDayOfMonthFromDateTime(cal.CurrentDateSelected).AddDays(1)));
                        cal.Events = cal.Events.OrderBy(x => x.StartDate).ToList();
                        cal.IsSuccessful = true;
                        return Json(cal, JsonRequestBehavior.AllowGet);
                    }
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return Json(cal, JsonRequestBehavior.AllowGet);
        }