public string LiveRecommandList(LiveNavFilter filter)
{
try
{
var recommands = LiveRecommandCache.Instance.Items[new RecommandKey(filter.platform, filter.auth, filter.navid)];
if (recommands.Count <= 0)
{
return(NoModeNav());
}
var pars = VideoParsUtils.FormateSearchVideoPars(filter);
var filters = VideoNodesUtil.CommonCustomFilter(filter);
if (filters.Count <= 0)
{
return(CreatePageList(recommands[0], recommands[0].Lists, filter, pars, false));
}
else
{
var videos = FilterList(recommands[0], filters, filter);
return(CreatePageList(recommands[0], videos, filter, pars, false));
}
}
catch (KeyNotFoundException)
{
return(NoPlatformNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// XML输出
/// </summary>
private void ResponseXml(TreeNode node, XElement xml, TreeleftFilter filter, VideoNodeKey key, bool isEx)
{
int count, allcount;
if (!isEx)
{
var filters = VideoNodesUtil.CommonCustomFilter(filter);
if (filters.Count <= 0)
{
count = GetChannelCount(node, key);
allcount = GetAllChannelCount(node, key) + count;
}
else
{
count = GetChannelExCount(node, key, filters, filter);
allcount = GetAllChannelExCount(node, key, filters, filter) + count;
}
}
else
{
var filters = VideoNodesUtil.FormateTagFilter(filter);
count = GetChannelExCount(node, key, filters, filter);
allcount = GetAllChannelExCount(node, key, filters, filter) + count;
}
xml.Add(new XElement("treeleft",
new XElement("tlid", node.Node.NodeID),
new XElement("father_tlid", node.Node.ParentNodeID),
new XElement("name", node.Language[filter.lang].Title),
new XElement("remark", node.Language[filter.lang].SubTitle),
new XElement("subtreeleft_count", node.Childrens.Count),
new XElement("subtreeleft_totalcount", node.ALLChildrens),
new XElement("subv_count", count),
new XElement("subv_totalcount", allcount)
));
}
public string LiveRecommandNav(LiveNavFilter filter)
{
try
{
var recommands = LiveRecommandCache.Instance.Items[new RecommandKey(filter.mode, filter.platform, filter.auth)];
var root = new XElement("navs");
var filters = VideoNodesUtil.CommonCustomFilter(filter);
if (filters.Count <= 0)
{
root.Add(from recommand in recommands select CreateNav(recommand, filter));
}
else
{
root.Add(from recommand in recommands let vs = FilterList(recommand, filters, filter) where vs.Count > 0 select CreateNav(recommand, filter));
}
return(root.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoModeNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 获取节目信息扩展接口
/// </summary>
public string LiveListsEx(LiveFilter filter)
{
try
{
var pars = VideoParsUtils.FormatLiveVideoPars(filter);
var filters = VideoNodesUtil.FormateLiveVideoExFilter(filter, pars);
var key = new VideoNodeKey(filter.platform, filter.type, filter.auth);
var query = LiveListCache.Instance.Items[key].Where(v =>
{
bool result = true;
foreach (var f in filters)
{
result = result && f(v, pars, filter);
}
return(result);
});
return(CreatePageList(VideoSortUtils <LiveVideoNode> .SortLiveVideos(query, filter, pars), filter, pars, key, true));
}
catch (KeyNotFoundException)
{
return(NoPlatLive());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 直播分类信息扩展接口
/// </summary>
public string LiveTypesEx(LiveFilter filter)
{
try
{
var key = new VideoNodeKey(filter.platform, filter.type, filter.auth);
var root = new XElement("types");
var filters = VideoNodesUtil.FormateTagFilter(filter);
root.Add(from livetype in LiveTypeDicCache.Instance.Items
where livetype.Channels.ContainsKey(key)
let count = GetChannelCount(livetype, key, filter, filters)
where count > 0
select new XElement("type",
new XElement("tid", livetype.ID),
new XElement("name", livetype.Language[filter.lang].Title),
new XElement("count", count),
new XElement("image", livetype.PicLink)
));
return(root.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoPlatLive());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string NavLists(NavFilter filter)
{
try
{
var key = new VideoNodeKey(filter.platform, 0, filter.auth);
var pars = VideoParsUtils.FormateSearchVideoPars(filter);
var filters = VideoNodesUtil.FormateVodFilter(filter);
var rel = RecommandCache.Instance.Dictionary[filter.navid];
var query = rel.Channels[key].Where(v =>
{
bool result = true;
var video = ListCache.Instance.Dictionary[v];
foreach (var f in filters)
{
result = result && f(video, filter);
}
return(result);
});
return(CreatePageList(rel, query, filter, pars, false));
}
catch (KeyNotFoundException)
{
return(NoPlatformNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 单维度扩展接口
/// </summary>
public string TagsEx(TagsFilter filter)
{
try
{
var tags = TagCache.Instance.Items[new TagNodeKey()
{
Dimension = filter.dimension, Type = filter.type
}];
var key = new VideoNodeKey(filter.platform, filter.type, filter.auth);
var xml = new XElement("tags");
var filters = VideoNodesUtil.FormateVodFilter(filter);
xml.Add(from tag in tags
where tag.Channels.ContainsKey(key)
let count = GetChannelCount(tag, key, filter, filters)
where count > 0
select new XElement("tag",
new XElement("name", tag.Language[filter.lang].Title),
new XElement("count", count)
));
return(xml.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string NavEx(NavFilter filter)
{
try
{
var res = RecommandCache.Instance.Items[filter.mode];
var xml = new XElement("navs");
var key = new VideoNodeKey(filter.platform, 0, filter.auth);
var filters = VideoNodesUtil.FormateVodFilter(filter);
xml.Add(from re in res
let count = GetChannelCount(re, key, filter, filters)
where count > 0
select new XElement("nav",
new XElement("navid", re.Id),
new XElement("name", re.Language[filter.lang].Title),
new XElement("count", count),
new XElement("image", re.PicLink)
));
return(xml.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoModeNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string ListByTags(ListFilter filter)
{
try
{
var pindex = VideoNodeKeyArray.Instance.Items[new VideoNodeKey(filter.platform, 0, filter.auth)];
var pars = VideoParsUtils.FormatListByTags(filter);
var filters = VideoNodesUtil.FormateVideoFilter(filter, pars);
var tag = pars.SortTag.Substring(0, pars.SortTag.LastIndexOf(":"));
var dimension = pars.SortTag.Substring(pars.SortTag.LastIndexOf(":") + 1);
IEnumerable <int> channels = new List <int>();
foreach (var type in BoxTypeCache.Instance.Items.Values)
{
var key = new TagNodeKey()
{
Dimension = dimension, Type = type.TypeID
};
if (TagCache.Instance.Items.ContainsKey(key))
{
var vkey = new VideoNodeKey(filter.platform, type.TypeID, filter.auth);
var node = TagCache.Instance.Items[key].FirstOrDefault(v => v.Language[CustomArray.LanguageArray[0]].Title == tag);
if (node != null && node.Channels.ContainsKey(vkey))
{
channels = channels.Union(node.Channels[vkey]);
}
}
}
var query = channels.Where(v =>
{
bool result = true;
var video = ListCache.Instance.Dictionary[v];
foreach (var f in filters)
{
result = result && f(video, pars, filter);
}
return(result);
}
);
return(CreatePageList(query, filter, pars, false));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string ImageRecommand(CoverFilter filter)
{
try
{
var pars = VideoParsUtils.FormateSearchVideoPars(filter);
var filters = VideoNodesUtil.CommonCustomFilter(filter);
var rel = CoverNavCache.Instance.Dictionary[filter.navid];
return(CreatePageList(rel, filter, pars, filters, false));
}
catch (KeyNotFoundException)
{
return(NoPlatformNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 分类扩展接口
/// </summary>
public string VideoTypesEx(TagsFilter filter)
{
try
{
var types = BoxTypeCache.Instance.Items;
var filters = VideoNodesUtil.CommonFilter(filter);
var root = new XElement("types");
foreach (var boxtype in types)
{
var videos = ListCache.Instance.Items[new VideoNodeKey(filter.platform, boxtype.Key, filter.auth)].OrderArray;
int count = 0;
for (var i = 0; i < videos.Count; i++)
{
bool result = true;
var v = ListCache.Instance.Dictionary[videos[i]];
foreach (var f in filters)
{
result = result && f(v, filter);
}
if (result)
{
count++;
}
}
root.Add(new XElement("type",
new XElement("tid", boxtype.Value.TypeID),
new XElement("name", boxtype.Value.Language[filter.lang].Title),
new XElement("count", count),
new XElement("image", boxtype.Value.PicLink),
new XElement("tag_dimesion", boxtype.Value.ResponseDimension),
new XElement("treeleft_support", boxtype.Value.TreeSupport)
));
}
return(root.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 多维度基本接口
/// </summary>
public string MultiTags(TagsFilter filter)
{
try
{
var dimensions = filter.dimension.Split(SplitArray.LineArray, StringSplitOptions.RemoveEmptyEntries).Distinct();
var filters = VideoNodesUtil.CommonCustomFilter(filter);
var xml = new XElement("tags");
foreach (var dimension in dimensions)
{
var tags = TagCache.Instance.Items[new TagNodeKey()
{
Dimension = dimension, Type = filter.type
}];
var key = new VideoNodeKey(filter.platform, filter.type, filter.auth);
IEnumerable <string> query = null;
if (filters.Count <= 0)
{
query = from tag in tags where tag.Channels.ContainsKey(key) select tag.Language[filter.lang].Title;
}
else
{
query = from tag in tags
where tag.Channels.ContainsKey(key)
let count = GetChannelCount(tag, key, filter, filters)
where count > 0
select tag.Language[filter.lang].Title;
}
xml.Add(new XElement("info",
new XAttribute("dimension", dimension),
BoxUtils.GetXmlCData(query.FormatListToStr(SplitArray.Line, 100))
));
}
return(xml.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string LiveRecommandNavEx(LiveNavFilter filter)
{
try
{
var recommands = LiveRecommandCache.Instance.Items[new RecommandKey(filter.mode, filter.platform, filter.auth)];
var root = new XElement("navs");
IEnumerable <XElement> query = null;
var filters = VideoNodesUtil.FormateTagFilter(filter);
query = from recommand in recommands let vs = FilterList(recommand, filters, filter) where vs.Count > 0 select CreateNavEx(recommand, vs.Count, filter);
root.Add(query);
return(root.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoModeNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
public string ImageNav(CoverFilter filter)
{
try
{
var res = CoverNavCache.Instance.Items[filter.navmode];
var key = new VideoNodeKey(filter.platform, 0, filter.auth);
var filters = VideoNodesUtil.CommonCustomFilter(filter);
var xml = new XElement("navs");
if (filters.Count <= 0)
{
xml.Add(from re in res
select new XElement("nav",
new XElement("navid", re.Id),
new XElement("name", re.Language[filter.lang].Title),
new XElement("image", re.PicLink)
));
}
else
{
xml.Add(from re in res
let count = GetChannelCount(re, key, filter, filters)
where count > 0
select new XElement("nav",
new XElement("navid", re.Id),
new XElement("name", re.Language[filter.lang].Title),
new XElement("image", re.PicLink)
));
}
return(xml.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoModeNav());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 多维度扩展接口
/// </summary>
public string MultiTagsEx(TagsFilter filter)
{
try
{
var dimensions = filter.dimension.Split(SplitArray.LineArray, StringSplitOptions.RemoveEmptyEntries).Distinct();
var xml = new XElement("tags");
foreach (var dimension in dimensions)
{
var tags = TagCache.Instance.Items[new TagNodeKey()
{
Dimension = dimension, Type = filter.type
}];
var key = new VideoNodeKey(filter.platform, filter.type, filter.auth);
var dimensionxml = new XElement("dimension", new XAttribute("name", dimension));
var filters = VideoNodesUtil.FormateVodFilter(filter);
dimensionxml.Add(from tag in tags
where tag.Channels.ContainsKey(key)
let count = GetChannelCount(tag, key, filter, filters)
where count > 0
select new XElement("tag",
new XElement("name", tag.Language[filter.lang].Title),
new XElement("count", count)
));
xml.Add(dimensionxml);
}
return(xml.ToString(SaveOptions.DisableFormatting));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
/// <summary>
/// 获取视频数据基本接口
/// </summary>
public string VideoList(ListFilter filter)
{
try
{
var pars = VideoParsUtils.FormatVideoPars(filter);
var vkey = new VideoNodeKey(filter.platform, filter.type, filter.auth);
var filters = VideoNodesUtil.FormateVideoFilter(filter, pars);
IEnumerable <int> channels;
if (filter.treeleftid != 0)
{
var node = TreeNodeCache.Instance.Items[filter.treeleftid];
if (node.Channels.ContainsKey(vkey))
{
channels = VideoSortUtils <VideoNode> .Sort(node.Channels[vkey], filter);
}
else
{
channels = new List <int>();
}
}
else if (!string.IsNullOrEmpty(pars.SortTag))
{
try
{
var tag = pars.SortTag.Substring(0, pars.SortTag.LastIndexOf(":"));
var dimension = pars.SortTag.Substring(pars.SortTag.LastIndexOf(":") + 1);
var key = new TagNodeKey()
{
Dimension = dimension, Type = filter.type
};
if (TagCache.Instance.Items.ContainsKey(key))
{
var node = TagCache.Instance.Items[key].FirstOrDefault(v => v.Language[CustomArray.LanguageArray[0]].Title == tag);
if (node != null && node.Channels.ContainsKey(vkey))
{
channels = node.Channels[vkey];
}
else
{
channels = new List <int>();
}
}
else
{
channels = new List <int>();
}
}
catch
{
return(BoxUtils.FormatErrorMsg("ntags分析错误"));
}
}
else
{
channels = ListCache.Instance.Items[vkey].OrderArray;
}
var query = channels.Where(v =>
{
bool result = true;
var video = ListCache.Instance.Dictionary[v];
foreach (var f in filters)
{
result = result && f(video, pars, filter);
}
return(result);
});
return(CreatePageList(VideoSortUtils <VideoNode> .Sort(query, filter), filter, pars, false));
}
catch (KeyNotFoundException)
{
return(NoPlatForm());
}
catch (Exception ex)
{
return(BoxUtils.FormatErrorMsg(ex));
}
}
