public static Calendar GetCalendarEvents(Guid memId, Guid uid, Guid calendarId, CalendarOwnerEntityEnum ownerType, int year, int month)
{
Random r = new Random();
var response = Network.SendPackage(Network.ConvertObjectToStream(new CalendarSendParams() { CurrentMemberId = memId, UserId = uid, Year = year, Month = month, CalendarId = calendarId, CalendarType = ownerType }), MobileConfig.LEAGUE_CALENDAR_LIST_URL + "?r=" + r.Next());
var stream = response.GetResponseStream();
StreamReader read = new StreamReader(stream);
string json = read.ReadToEnd();
return Json.DeserializeObject<Calendar>(json);
}
/// <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;
}
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;
}
/// <summary>
/// gets the owner entity id of the league or the federation
/// </summary>
/// <param name="calendarId"></param>
/// <param name="owner"></param>
/// <returns></returns>
public static Guid GetEntityOwnerId(Guid calendarId, CalendarOwnerEntityEnum owner)
{
try
{
var dc = new ManagementContext();
var calDb = (from xx in dc.Calendar
where xx.CalendarId == calendarId
select new
{
xx.FederationOwners,
xx.LeagueOwners
}).FirstOrDefault();
if (calDb == null)
return new Guid();
if (calDb.FederationOwners.FirstOrDefault() != null)
return calDb.FederationOwners.FirstOrDefault().Federation.FederationId;
if (calDb.LeagueOwners.FirstOrDefault() != null)
return calDb.LeagueOwners.FirstOrDefault().League.LeagueId;
}
catch (Exception exception)
{
ErrorDatabaseManager.AddException(exception, exception.GetType());
}
return new Guid();
}
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;
}
/// <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;
}
