private static RouteValueDictionary getSessionPageRouteValueDictionary(RouteData routeData, int pageIndex)
{
var rvd = new RouteValueDictionary();
foreach (KeyValuePair <string, object> item in routeData.Values)
{
if (item.Key != "X-Requested-With")
{
rvd.Add(item.Key, item.Value);
}
}
rvd.Remove("controller");
rvd.Remove("action");
rvd.Remove("eventname");
rvd.Remove("scheduleItemType");
rvd.Remove("dataFormat");
var criteria = new ScheduleItemFilterCriteria(routeData.Values["scheduleItemFilterCriteria"] as string)
{
PageIndex = pageIndex, //ForUser = forUser
};
rvd["scheduleItemFilterCriteria"] = criteria.ToUrl();
return(rvd);
}
public IPageOfItems <ScheduleItem> GetScheduleItems(Event evnt, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
int pageIndex = 0;
int pageSize = 50;
if (context.RequestDataFormat == RequestDataFormat.Web)
{
pageIndex = scheduleItemFilterCriteria.PageIndex;
pageSize = scheduleItemFilterCriteria.PageSize;
}
IPageOfItems <ScheduleItem> scheduleItems =
cache.GetItems <IPageOfItems <ScheduleItem>, ScheduleItem>(
string.Format("GetScheduleItems-FilterCriteria:{0}", scheduleItemFilterCriteria),
new CachePartition(pageIndex, pageSize),
() => repository.GetScheduleItems(new PagingInfo(pageIndex, pageSize), evnt, context.User.IsAuthenticated && context.User.Cast <User>() != null ? context.User.Cast <User>().ID : Guid.Empty, scheduleItemFilterCriteria).FillTags(tagService),
si => si.GetDependencies()
);
if (context.RequestDataFormat.IsFeed())
{
scheduleItems = scheduleItems.Since(si => si.Modified, context.HttpContext.Request.IfModifiedSince());
}
return(scheduleItems);
}
public OxiteViewModelItems <ScheduleItem> ListByEvent(Event evnt, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
if (evnt == null)
{
return(null);
}
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItems(evnt, scheduleItemFilterCriteria);
return(new OxiteViewModelItems <ScheduleItem>(scheduleItems)
{
Container = evnt
});
}
public OxiteViewModelItems <ScheduleItem> Summary(EventAddress eventAddress)
{
if (!_context.User.IsInRole("Admin"))
{
return(new OxiteViewModelItems <ScheduleItem>());
}
var criteria = new ScheduleItemFilterCriteria {
PageIndex = 0, PageSize = 1000000
};
var sessions = _scheduleItemService.GetScheduleItemsUncached(eventAddress, criteria);
return(new OxiteViewModelItems <ScheduleItem>(sessions));
}
public OxiteViewModelItems <ScheduleItem> SiteMap(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
Event evnt = eventService.GetEvent(eventAddress);
if (evnt == null)
{
return(null);
}
scheduleItemFilterCriteria.PageSize = 2000;
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItems(eventAddress, scheduleItemFilterCriteria);
return(new OxiteViewModelItems <ScheduleItem>(scheduleItems)
{
Container = evnt
});
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
ScheduleItemFilterCriteria scheduleItemFilterCriteria =
new ScheduleItemFilterCriteria(controllerContext.RouteData.Values["scheduleItemFilterCriteria"] as string);
if (string.IsNullOrEmpty(scheduleItemFilterCriteria.ScheduleItemType) &&
controllerContext.RouteData.Values.ContainsKey("scheduleItemType"))
{
scheduleItemFilterCriteria.ScheduleItemType =
controllerContext.RouteData.Values["scheduleItemType"] as string;
}
if (string.IsNullOrEmpty(scheduleItemFilterCriteria.Term) &&
!string.IsNullOrEmpty(controllerContext.HttpContext.Request.QueryString["term"]))
{
scheduleItemFilterCriteria.Term =
controllerContext.HttpContext.Request.QueryString["term"];
}
return(scheduleItemFilterCriteria);
}
public OxiteViewModelItems <ScheduleItem> ListByUserPrintable(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
var user = context.User != null?context.User.Cast <UserAuthenticated>() : null;
scheduleItemFilterCriteria.PageSize = 200;
if (user == null)
{
return(null);
}
ViewData["Printable"] = true;
return(ListByUserImpl(eventAddress, scheduleItemFilterCriteria));
}
public OxiteViewModelItems <ScheduleItem> ListByUser(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(ListByUserImpl(eventAddress, scheduleItemFilterCriteria));
}
public OxiteViewModelItems <ScheduleItem> ListByEventWithVideo(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
scheduleItemFilterCriteria.WithFileTypes.Add("video");
scheduleItemFilterCriteria.PageSize = 100000;
return(ListByEvent(eventAddress, scheduleItemFilterCriteria));
}
private OxiteViewModelItems <ScheduleItem> ListByEventImpl(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
Event evnt = eventService.GetEvent(eventAddress);
if (evnt == null)
{
return(null);
}
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItems(eventAddress, scheduleItemFilterCriteria);
SetUserScheduleStatus();
return(new OxiteViewModelItems <ScheduleItem>(scheduleItems)
{
Container = evnt
});
}
public OxiteViewModelItemItems <Tag, ScheduleItem> ListByEventAndTag(Event evnt, Tag tag, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
if (evnt == null)
{
return(null);
}
if (tag == null)
{
return(null);
}
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItemsByTag(evnt, tag, scheduleItemFilterCriteria);
return(new OxiteViewModelItemItems <Tag, ScheduleItem>(tag, scheduleItems)
{
Container = evnt
});
}
public IPageOfItems <ScheduleItem> GetScheduleItemsByTag(EventAddress eventAddress, Guid tagID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
var result =
cache.GetItems <IPageOfItems <ScheduleItem>, ScheduleItem>(
string.Format("GetScheduleItems-Event:{0},Tag:{1:N},FilterCriteria:{2}", eventAddress.EventName, tagID, scheduleItemFilterCriteria),
new CachePartition(scheduleItemFilterCriteria.PageIndex, scheduleItemFilterCriteria.PageSize),
() => repository.GetScheduleItemsByTag(eventAddress, context.User.IsAuthenticated && context.User.Cast <UserAuthenticated>() != null ? context.User.Cast <UserAuthenticated>().ID : Guid.Empty, tagID, scheduleItemFilterCriteria).GetPage(scheduleItemFilterCriteria.PageIndex, scheduleItemFilterCriteria.PageSize).FillTags(tagService),
si => si.GetDependencies()
);
SetScheduleItemUsers(result);
return(result);
}
public IPageOfItems <ScheduleItem> GetScheduleItems(ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(GetScheduleItems(null, scheduleItemFilterCriteria).FillTags(tagService));
}
public IPageOfItems <ScheduleItem> GetScheduleItemsByTag(Event evnt, Guid userID, Tag tag, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
var query =
getScheduleItems(evnt, userID, scheduleItemFilterCriteria)
.Where(si => si.oxite_Conferences_ScheduleItemTagRelationships.Any(sitr => sitr.TagID == tag.ID));
return(projectScheduleItems(query).GetPage(new PagingInfo(scheduleItemFilterCriteria.PageIndex, scheduleItemFilterCriteria.PageSize)));
}
private OxiteViewModelItems <ScheduleItem> ListByUserImpl(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
Event evnt = eventService.GetEvent(eventAddress);
if (evnt == null)
{
return(null);
}
scheduleItemFilterCriteria.ForUser = true;
// note (dcrenna) this still cannot be cached yet so that changes pick up from all views
var scheduleItems = scheduleItemService.GetScheduleItemsUncachedByUser(eventAddress, scheduleItemFilterCriteria);
SetUserScheduleStatus();
return(new OxiteViewModelItems <ScheduleItem>(scheduleItems)
{
Container = evnt
});
}
public IPageOfItems <ScheduleItem> GetScheduleItems(PagingInfo pagingInfo, Event evnt, Guid userID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(projectScheduleItems(getScheduleItems(evnt, userID, scheduleItemFilterCriteria)).GetPage(pagingInfo));
}
public IPageOfItems <ScheduleItem> GetScheduleItems(PagingInfo pagingInfo, Event evnt, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(GetScheduleItems(pagingInfo, evnt, Guid.Empty, scheduleItemFilterCriteria));
}
private IQueryable <oxite_Conferences_ScheduleItem> getScheduleItems(Event evnt, Guid userID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
IQueryable <oxite_Conferences_ScheduleItem> query = from si in context.oxite_Conferences_ScheduleItems select si;
//todo: (nheskew) probably should only look through speaker names if there isn't speaker name criteria
if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.Term))
{
query = query
.Where(
si =>
si.Title.Contains(scheduleItemFilterCriteria.Term) ||
si.Body.Contains(scheduleItemFilterCriteria.Term) ||
si.Slug.Contains(scheduleItemFilterCriteria.Term) ||
si.Location.Contains(scheduleItemFilterCriteria.Term) ||
si.oxite_Conferences_ScheduleItemSpeakerRelationships
.Any(
sis =>
sis.oxite_Conferences_Speaker.SpeakerDisplayName.Contains(scheduleItemFilterCriteria.Term))
);
}
if (scheduleItemFilterCriteria.ForUser && userID != Guid.Empty)
{
query = query
.Where(
si => si.oxite_Conferences_ScheduleItemUserRelationships
.Any(siu => siu.UserID == userID)
);
}
if (evnt != null)
{
query = query
.Where(si => si.oxite_Conferences_Event.EventID == evnt.ID);
}
//if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.ScheduleItemType))
// query = query
// .Where(si => string.Compare(si.Type, scheduleItemFilterCriteria.ScheduleItemType, true) == 0);
if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.SpeakerName))
{
query = query
.Where(
si => si.oxite_Conferences_ScheduleItemSpeakerRelationships
.Any(
sis =>
string.Compare(sis.oxite_Conferences_Speaker.SpeakerName,
scheduleItemFilterCriteria.SpeakerName, true) == 0)
);
}
query = scheduleItemFilterCriteria.OrderByPopular
? query.OrderBy(si => si.ModifiedDate)
//todo: (nheskew)order by some pre-calculated popularity score
: query.OrderByDescending(si => si.ModifiedDate);
return(query);
}
// todo (dcrenna): remove this as soon as distributed caching is available
public IPageOfItems <ScheduleItem> GetScheduleItemsUncachedByUser(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
int pageIndex = 0;
int pageSize = 50;
if (context.RequestDataFormat == RequestDataFormat.Web)
{
pageIndex = scheduleItemFilterCriteria.PageIndex;
pageSize = scheduleItemFilterCriteria.PageSize;
}
var cacheKey = string.Format("GetScheduleItems-FilterCriteria:{0}", scheduleItemFilterCriteria);
var authenticatedUser = context.User.IsAuthenticated && context.User.Cast <UserAuthenticated>() != null;
var userId = Guid.Empty;
if (authenticatedUser)
{
userId = context.User.Cast <UserAuthenticated>().ID;
cacheKey += String.Concat("-UserID:", userId);
}
var items = repository.GetScheduleItems(eventAddress, userId, scheduleItemFilterCriteria);//.OrderBy(si => si.Start);
var scheduleItems = items.GetPage(pageIndex, pageSize).FillTags(tagService);
if (context.RequestDataFormat.IsFeed())
{
scheduleItems = scheduleItems.Since(si => si.Modified, context.HttpContext.Request.IfModifiedSince());
}
SetScheduleItemUsers(scheduleItems);
return(scheduleItems);
}
public IQueryable <ScheduleItem> GetScheduleItems(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(GetScheduleItems(eventAddress, Guid.Empty, scheduleItemFilterCriteria));
}
public IPageOfItems <ScheduleItem> GetScheduleItemsUncached(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
int pageIndex = 0;
int pageSize = 50;
if (context.RequestDataFormat == RequestDataFormat.Web)
{
pageIndex = scheduleItemFilterCriteria.PageIndex;
pageSize = scheduleItemFilterCriteria.PageSize;
}
var items = repository.GetScheduleItems(eventAddress, scheduleItemFilterCriteria);//.OrderBy(si => si.Start);
var scheduleItems = items.GetPage(pageIndex, pageSize).FillTags(tagService);
if (context.RequestDataFormat.IsFeed())
{
scheduleItems = scheduleItems.Since(si => si.Modified, context.HttpContext.Request.IfModifiedSince());
}
return(scheduleItems);
}
public IQueryable <ScheduleItem> GetScheduleItemsByTag(EventAddress eventAddress, Guid userID, Guid tagID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
var query =
getScheduleItems(eventAddress, userID, scheduleItemFilterCriteria)
.Where(si => si.oxite_Conferences_ScheduleItemTagRelationships.Any(sitr => sitr.TagID == tagID));
return(projectScheduleItems(query));
}
public IPageOfItems <ScheduleItem> GetScheduleItems(EventAddress eventAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
string dataFormat = context.RequestContext.RouteData.Values["dataFormat"] as String;
int pageIndex = scheduleItemFilterCriteria.PageIndex;
int pageSize = scheduleItemFilterCriteria.PageSize;
if (dataFormat != null)
{
dataFormat = dataFormat.ToLower();
if (dataFormat == "rss" || dataFormat == "atom" || dataFormat == "sign" || dataFormat == "ics")
{
pageIndex = 0;
pageSize = 1000;
}
}
var cacheKey = string.Format("GetScheduleItems-FilterCriteria:{0}", scheduleItemFilterCriteria);
var authenticatedUser = context.User.IsAuthenticated && context.User.Cast <UserAuthenticated>() != null;
var userId = Guid.Empty;
if (authenticatedUser)
{
userId = context.User.Cast <UserAuthenticated>().ID;
cacheKey += String.Concat("-UserID:", userId);
}
IPageOfItems <ScheduleItem> scheduleItems =
cache.GetItems <IPageOfItems <ScheduleItem>, ScheduleItem>(
cacheKey,
new CachePartition(pageIndex, pageSize),
() => repository.GetScheduleItems(eventAddress, userId, scheduleItemFilterCriteria).GetPage(pageIndex, pageSize).FillTags(tagService),
si => si.GetDependencies()
);
SetScheduleItemUsers(scheduleItems);
return(scheduleItems);
}
public IPageOfItems <ScheduleItem> GetScheduleItemsByTag(Event evnt, Tag tag, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return
(cache.GetItems <IPageOfItems <ScheduleItem>, ScheduleItem>(
string.Format("GetScheduleItems-Event:{0},Tag:{1:N},FilterCriteria:{2}", evnt.Name, tag.ID, scheduleItemFilterCriteria),
new CachePartition(scheduleItemFilterCriteria.PageIndex, scheduleItemFilterCriteria.PageSize),
() => repository.GetScheduleItemsByTag(evnt, context.User.IsAuthenticated && context.User.Cast <User>() != null ? context.User.Cast <User>().ID : Guid.Empty, tag, scheduleItemFilterCriteria).FillTags(tagService),
si => si.GetDependencies()
));
}
private IQueryable <oxite_Conferences_ScheduleItem> getScheduleItems(EventAddress eventAddress, Guid userID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
IQueryable <oxite_Conferences_ScheduleItem> query = from si in context.oxite_Conferences_ScheduleItems
select si;
//todo: (nheskew) probably should only look through speaker names if there isn't speaker name criteria
if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.Term))
{
query = query
.Where(
si =>
si.Title.Contains(scheduleItemFilterCriteria.Term) ||
si.Body.Contains(scheduleItemFilterCriteria.Term) ||
si.Slug.Contains(scheduleItemFilterCriteria.Term) ||
si.Location.Contains(scheduleItemFilterCriteria.Term) ||
si.oxite_Conferences_ScheduleItemSpeakerRelationships
.Any(
sis =>
sis.oxite_Conferences_Speaker.SpeakerFirstName.Contains(scheduleItemFilterCriteria.Term) ||
sis.oxite_Conferences_Speaker.SpeakerLastName.Contains(scheduleItemFilterCriteria.Term) ||
si.oxite_Conferences_ScheduleItemTagRelationships.Any(
sitr =>
sitr.TagDisplayName.Contains(scheduleItemFilterCriteria.Term))
)
);
}
if (scheduleItemFilterCriteria.ForUser && userID != Guid.Empty)
{
query = query
.Where(
si => si.oxite_Conferences_ScheduleItemUserRelationships
.Any(siu => siu.UserID == userID)
);
}
if (eventAddress != null)
{
query = query
.Where(si => string.Compare(si.oxite_Conferences_Event.EventName, eventAddress.EventName, true) == 0);
}
//if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.ScheduleItemType))
// query = query
// .Where(si => string.Compare(si.Type, scheduleItemFilterCriteria.ScheduleItemType, true) == 0);
if (!string.IsNullOrEmpty(scheduleItemFilterCriteria.SpeakerName))
{
query = query
.Where(
si => si.oxite_Conferences_ScheduleItemSpeakerRelationships
.Any(
sis =>
string.Compare(sis.oxite_Conferences_Speaker.SpeakerName,
scheduleItemFilterCriteria.SpeakerName, true) == 0)
);
}
query = scheduleItemFilterCriteria.OrderByPopular
? query.OrderBy(si => si.CreatedDate)
//todo: (nheskew)order by some pre-calculated popularity score
: query.OrderByDescending(si => si.CreatedDate);
if (scheduleItemFilterCriteria.ForUser && userID != Guid.Empty)
{
query = query.OrderBy(s => s.StartTime);
}
// note only videos supported currently
if (scheduleItemFilterCriteria.WithFileTypes.Count > 0 &&
scheduleItemFilterCriteria.WithFileTypes.Contains("video"))
{
query = query.Where(si => si.oxite_Conferences_ScheduleItemFileRelationships
.Any(
sif =>
sif.oxite_File.TypeName == "WMVHigh" ||
sif.oxite_File.TypeName == "WMVStreamingOnly"));
}
return(query);
}
public OxiteViewModelItems <ScheduleItem> ListByEventAndWorkshops(EventAddress eventAddress, TagAddress tagAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
Event evnt = eventService.GetEvent(eventAddress);
if (evnt == null)
{
return(null);
}
Tag tag = tagService.GetTag(tagAddress);
if (!string.IsNullOrEmpty(tagAddress.TagName) && tag == null)
{
return(null);
}
ScheduleItemTag scheduleItemTag = scheduleItemService.GetScheduleItemTag(tagService.GetTag(tagAddress));
if (!string.IsNullOrEmpty(tagAddress.TagName) && scheduleItemTag == null)
{
return(null);
}
scheduleItemFilterCriteria.PageSize = 100; //show all workshops on workshop page
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItemsByTag(eventAddress, scheduleItemTag != null ? scheduleItemTag.ID : Guid.Empty, scheduleItemFilterCriteria);
SetUserScheduleStatus();
var model = new OxiteViewModelItems <ScheduleItem>(scheduleItems)
{
Container = evnt
};
model.AddModelItem(scheduleItemTag);
return(model);
}
public IQueryable <ScheduleItem> GetScheduleItems(EventAddress eventAddress, Guid userID, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(projectScheduleItems(getScheduleItems(eventAddress, userID, scheduleItemFilterCriteria)));
}
public OxiteViewModelItemItems <ScheduleItemTag, ScheduleItem> ListByEventAndTagAndUser(EventAddress eventAddress, TagAddress tagAddress, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
Event evnt = eventService.GetEvent(eventAddress);
if (evnt == null)
{
return(null);
}
Tag tag = tagService.GetTag(tagAddress);
if (!string.IsNullOrEmpty(tagAddress.TagName) && tag == null)
{
return(null);
}
scheduleItemFilterCriteria.ForUser = true;
ScheduleItemTag scheduleItemTag = scheduleItemService.GetScheduleItemTag(tagService.GetTag(tagAddress));
if (!string.IsNullOrEmpty(tagAddress.TagName) && scheduleItemTag == null)
{
return(null);
}
IPageOfItems <ScheduleItem> scheduleItems = scheduleItemService.GetScheduleItemsByTag(eventAddress, scheduleItemTag != null ? scheduleItemTag.ID : Guid.Empty, scheduleItemFilterCriteria);
SetUserScheduleStatus();
return(new OxiteViewModelItemItems <ScheduleItemTag, ScheduleItem>(scheduleItemTag, scheduleItems)
{
Container = evnt
});
}
public OxiteViewModelItems <ScheduleItem> List(ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
SetUserScheduleStatus();
return(new OxiteViewModelItems <ScheduleItem>(scheduleItemService.GetScheduleItems(scheduleItemFilterCriteria)));
}
public static string Sessions(this UrlHelper urlHelper, ScheduleItemFilterCriteria scheduleItemFilterCriteria)
{
return(urlHelper.RouteUrl("PDC09SessionsUrl", new { scheduleItemFilterCriteria = scheduleItemFilterCriteria.ToUrl() }));
}
