public static List <GroupFilter> InitCache()
{
string t = "GroupFilter";
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, string.Empty);
GroupFilterConditionRepository repConds = new GroupFilterConditionRepository();
GroupFilterRepository repo = new GroupFilterRepository();
List <GroupFilter> filters = repo.InternalGetAll();
Cache = new PocoCache <int, GroupFilter>(filters, a => a.GroupFilterID);
Changes.AddOrUpdateRange(Cache.Keys);
Parents = Cache.CreateIndex(a => a.ParentGroupFilterID ?? 0);
Types =
new BiDictionaryManyToMany <int, GroupFilterConditionType>(Cache.Values.ToDictionary(
a => a.GroupFilterID,
a => a.Types));
List <GroupFilter> recalc = new List <GroupFilter>();
foreach (GroupFilter g in Cache.Values.ToList())
{
if (g.GroupFilterID != 0 && g.GroupsIdsVersion < GroupFilter.GROUPFILTER_VERSION ||
g.GroupConditionsVersion < GroupFilter.GROUPCONDITIONS_VERSION)
{
if (g.GroupConditionsVersion == 0)
{
g.Conditions = repConds.GetByGroupFilterID(g.GroupFilterID);
}
repo.Save(g, true);
recalc.Add(g);
}
}
return(recalc);
}
public void Save(AnimeGroup grp, bool updategrpcontractstats, bool recursive, bool verifylockedFilters = true)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
HashSet <GroupFilterConditionType> types;
lock (grp)
{
if (grp.AnimeGroupID == 0)
//We are creating one, and we need the AnimeGroupID before Update the contracts
{
grp.Contract = null;
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(grp);
transaction.Commit();
}
}
types = grp.UpdateContract(session, updategrpcontractstats);
//Types will contains the affected GroupFilterConditionTypes
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(grp);
transaction.Commit();
}
Changes.AddOrUpdate(grp.AnimeGroupID);
Cache.Update(grp);
}
if (verifylockedFilters)
{
GroupFilterRepository.CreateOrVerifyTagsAndYearsFilters(false, grp.Contract.Stat_AllTags, grp.Contract.Stat_AirDate_Min);
//This call will create extra years or tags if the Group have a new year or tag
grp.UpdateGroupFilters(types, null);
}
if (grp.AnimeGroupParentID.HasValue && recursive)
{
AnimeGroup pgroup = GetByID(session, grp.AnimeGroupParentID.Value);
// This will avoid the recursive error that would be possible, it won't update it, but that would be
// the least of the issues
if (pgroup != null && pgroup.AnimeGroupParentID == grp.AnimeGroupID)
{
Save(pgroup, updategrpcontractstats, true, verifylockedFilters);
}
}
}
}
public static void InitCacheSecondPart(List <GroupFilter> recalc)
{
string t = "GroupFilter";
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, string.Empty);
GroupFilterRepository repo = new GroupFilterRepository();
foreach (GroupFilter g in Cache.Values.ToList())
{
if (g.GroupsIdsVersion < GroupFilter.GROUPFILTER_VERSION ||
g.GroupConditionsVersion < GroupFilter.GROUPCONDITIONS_VERSION ||
g.SeriesIdsVersion < GroupFilter.SERIEFILTER_VERSION)
{
if (!recalc.Contains(g))
{
recalc.Add(g);
}
}
}
int max = recalc.Count;
int cnt = 0;
foreach (GroupFilter gf in recalc)
{
cnt++;
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
Properties.Resources.Filter_Recalc + " " + gf.GroupFilterName + " - " + cnt + "/" + max);
if (gf.GroupsIdsVersion < GroupFilter.GROUPFILTER_VERSION ||
gf.GroupConditionsVersion < GroupFilter.GROUPCONDITIONS_VERSION)
{
gf.EvaluateAnimeGroups();
}
if (gf.SeriesIdsVersion < GroupFilter.SERIEFILTER_VERSION ||
gf.GroupConditionsVersion < GroupFilter.GROUPCONDITIONS_VERSION)
{
gf.EvaluateAnimeSeries();
}
repo.Save(gf);
}
}
private static void CreateInitialGroupFilters()
{
// group filters
GroupFilterRepository repFilters = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
if (repFilters.GetAll().Count() > 0) return;
// Favorites
GroupFilter gf = new GroupFilter();
gf.GroupFilterName = "Favorites";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.Favourite;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// Missing Episodes
gf = new GroupFilter();
gf.GroupFilterName = "Missing Episodes";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.MissingEpisodesCollecting;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// Newly Added Series
gf = new GroupFilter();
gf.GroupFilterName = "Newly Added Series";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.SeriesCreatedDate;
gfc.ConditionOperator = (int)GroupFilterOperator.LastXDays;
gfc.ConditionParameter = "10";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// Newly Airing Series
gf = new GroupFilter();
gf.GroupFilterName = "Newly Airing Series";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.AirDate;
gfc.ConditionOperator = (int)GroupFilterOperator.LastXDays;
gfc.ConditionParameter = "30";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// Votes Needed
gf = new GroupFilter();
gf.GroupFilterName = "Votes Needed";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.CompletedSeries;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasUnwatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Exclude;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.UserVotedAny;
gfc.ConditionOperator = (int)GroupFilterOperator.Exclude;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// Recently Watched
gf = new GroupFilter();
gf.GroupFilterName = "Recently Watched";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.EpisodeWatchedDate;
gfc.ConditionOperator = (int)GroupFilterOperator.LastXDays;
gfc.ConditionParameter = "10";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
// TvDB/MovieDB Link Missing
gf = new GroupFilter();
gf.GroupFilterName = "TvDB/MovieDB Link Missing";
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
repFilters.Save(gf);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.AssignedTvDBOrMovieDBInfo;
gfc.ConditionOperator = (int)GroupFilterOperator.Exclude;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
}
public void UpdateGroupFilterUsingGroup(int groupid)
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
JMMUserRepository repUser = new JMMUserRepository();
GroupFilterRepository repGrpFilter = new GroupFilterRepository();
AnimeGroup grp = repGroups.GetByID(groupid);
if (grp.AnimeGroupParentID.HasValue)
return;
foreach (JMMUser user in repUser.GetAll())
{
AnimeGroup_User userRec = repUserGroups.GetByUserAndGroupID(user.JMMUserID, groupid);
Dictionary<int, HashSet<int>> groupfilters;
if (StatUserGroupFilter.ContainsKey(user.JMMUserID))
groupfilters = StatUserGroupFilter[user.JMMUserID];
else
{
groupfilters = new Dictionary<int, HashSet<int>>();
StatUserGroupFilter.Add(user.JMMUserID, groupfilters);
}
List<GroupFilter> gfs = repGrpFilter.GetAll();
GroupFilter gfgf = new GroupFilter();
gfgf.GroupFilterName = "All";
gfs.Add(gfgf);
foreach (GroupFilter gf in gfs)
{
HashSet<int> groups;
if (groupfilters.ContainsKey(gf.GroupFilterID))
groups = groupfilters[gf.GroupFilterID];
else
{
groups = new HashSet<int>();
groupfilters.Add(gf.GroupFilterID, groups);
}
if (groups.Contains(groupid))
groups.Remove(groupid);
if (EvaluateGroupFilter(gf, grp, user, userRec))
groups.Add(grp.AnimeGroupID);
}
}
}
public static void CreateOrVerifyTagsAndYearsFilters(bool frominit = false, HashSet <string> tags = null, DateTime?airdate = null)
{
GroupFilterRepository repFilters = new GroupFilterRepository();
using (var session = JMMService.SessionFactory.OpenSession())
{
string t = "GroupFilter";
List <GroupFilter> lockedGFs = repFilters.GetLockedGroupFilters(session);
AniDB_TagRepository tagsrepo = new AniDB_TagRepository();
AnimeGroupRepository grouprepo = new AnimeGroupRepository();
GroupFilter tagsdirec = lockedGFs.FirstOrDefault(a => a.FilterType == (int)(GroupFilterType.Directory | GroupFilterType.Tag));
if (tagsdirec != null)
{
HashSet <string> alltags;
if (tags == null)
{
alltags = new HashSet <string>(tagsrepo.GetAll(session).Select(a => a.TagName).Distinct(StringComparer.InvariantCultureIgnoreCase), StringComparer.InvariantCultureIgnoreCase);
}
else
{
alltags = new HashSet <string>(tags.Distinct(StringComparer.InvariantCultureIgnoreCase), StringComparer.InvariantCultureIgnoreCase);
}
HashSet <string> notin = new HashSet <string>(lockedGFs.Where(a => a.FilterType == (int)GroupFilterType.Tag).Select(a => a.Conditions.FirstOrDefault()?.ConditionParameter), StringComparer.InvariantCultureIgnoreCase);
alltags.ExceptWith(notin);
int max = alltags.Count;
int cnt = 0;
//AniDB Tags are in english so we use en-us culture
TextInfo tinfo = new CultureInfo("en-US", false).TextInfo;
foreach (string s in alltags)
{
cnt++;
if (frominit)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
Properties.Resources.Filter_CreatingTag + " '" + s + "'" + Properties.Resources.Filter_Filter + cnt + "/" + max);
}
GroupFilter yf = new GroupFilter
{
ParentGroupFilterID = tagsdirec.GroupFilterID,
InvisibleInClients = 0,
GroupFilterName = tinfo.ToTitleCase(s.Replace("`", "'")),
BaseCondition = 1,
Locked = 1,
SortingCriteria = "5;1",
FilterType = (int)GroupFilterType.Tag
};
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.Tag;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = s;
gfc.GroupFilterID = yf.GroupFilterID;
yf.Conditions.Add(gfc);
yf.EvaluateAnimeGroups();
yf.EvaluateAnimeSeries();
repFilters.Save(yf);
}
}
GroupFilter yearsdirec = lockedGFs.FirstOrDefault(a => a.FilterType == (int)(GroupFilterType.Directory | GroupFilterType.Year));
if (yearsdirec != null)
{
HashSet <string> allyears;
if (airdate == null)
{
List <Contract_AnimeGroup> grps =
grouprepo.GetAll().Select(a => a.Contract).Where(a => a != null).ToList();
if (grps.Any(a => a.Stat_AirDate_Min.HasValue && a.Stat_AirDate_Max.HasValue))
{
DateTime maxtime =
grps.Where(a => a.Stat_AirDate_Max.HasValue).Max(a => a.Stat_AirDate_Max.Value);
DateTime mintime =
grps.Where(a => a.Stat_AirDate_Min.HasValue).Min(a => a.Stat_AirDate_Min.Value);
allyears =
new HashSet <string>(
Enumerable.Range(mintime.Year, maxtime.Year - mintime.Year + 1)
.Select(a => a.ToString()), StringComparer.InvariantCultureIgnoreCase);
}
else
{
allyears = new HashSet <string>();
}
}
else
{
allyears = new HashSet <string>(new string[] { airdate.Value.Year.ToString() });
}
HashSet <string> notin =
new HashSet <string>(
lockedGFs.Where(a => a.FilterType == (int)GroupFilterType.Year)
.Select(a => a.Conditions.FirstOrDefault()?.ConditionParameter),
StringComparer.InvariantCultureIgnoreCase);
allyears.ExceptWith(notin);
int max = allyears.Count;
int cnt = 0;
foreach (string s in allyears)
{
cnt++;
if (frominit)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
Properties.Resources.Filter_CreatingYear + " '" + s + "' " + Properties.Resources.Filter_Filter + cnt + "/" + max);
}
GroupFilter yf = new GroupFilter
{
ParentGroupFilterID = yearsdirec.GroupFilterID,
InvisibleInClients = 0,
GroupFilterName = s,
BaseCondition = 1,
Locked = 1,
SortingCriteria = "5;1",
FilterType = (int)GroupFilterType.Year
};
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.Year;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = s;
gfc.GroupFilterID = yf.GroupFilterID;
yf.Conditions.Add(gfc);
yf.EvaluateAnimeGroups();
yf.EvaluateAnimeSeries();
repFilters.Save(yf);
}
}
}
}
public string DeleteGroupFilter(int groupFilterID)
{
try
{
GroupFilterRepository repGF = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
GroupFilter gf = repGF.GetByID(groupFilterID);
if (gf == null)
return "Group Filter not found";
// delete all the conditions first
foreach (GroupFilterCondition gfc in gf.FilterConditions)
repGFC.Delete(gfc.GroupFilterConditionID);
repGF.Delete(groupFilterID);
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public Contract_GroupFilterExtended GetGroupFilterExtended(int groupFilterID, int userID)
{
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
GroupFilter gf = repGF.GetByID(session, groupFilterID);
if (gf == null) return null;
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(session, userID);
if (user == null) return null;
Contract_GroupFilterExtended contract = gf.ToContractExtended(session, user);
return contract;
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return null;
}
public List<Contract_AnimeGroup> GetAnimeGroupsForFilter(int groupFilterID, int userID, bool getSingleSeriesGroups)
{
List<Contract_AnimeGroup> retGroups = new List<Contract_AnimeGroup>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
DateTime start = DateTime.Now;
GroupFilterRepository repGF = new GroupFilterRepository();
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(session, userID);
if (user == null) return retGroups;
GroupFilter gf = null;
if (groupFilterID == -999)
{
// all groups
gf = new GroupFilter();
gf.GroupFilterName = "All";
}
else
{
gf = repGF.GetByID(session, groupFilterID);
if (gf == null) return retGroups;
}
//Contract_GroupFilterExtended contract = gf.ToContractExtended(user);
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
AnimeGroup_UserRepository repUserRecords = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecords = repUserRecords.GetByUserID(session, userID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User userRec in userRecords)
dictUserRecords[userRec.AnimeGroupID] = userRec;
TimeSpan ts = DateTime.Now - start;
string msg = string.Format("Got groups for filter DB: {0} - {1} in {2} ms", gf.GroupFilterName, allGrps.Count, ts.TotalMilliseconds);
logger.Info(msg);
start = DateTime.Now;
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
List<AnimeSeries> allSeries = new List<AnimeSeries>();
if (getSingleSeriesGroups)
allSeries = repSeries.GetAll(session);
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(user.JMMUserID)) && (StatsCache.Instance.StatUserGroupFilter[user.JMMUserID].ContainsKey(gf.GroupFilterID)))
{
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[user.JMMUserID][gf.GroupFilterID];
foreach (AnimeGroup grp in allGrps)
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(grp.AnimeGroupID))
userRec = dictUserRecords[grp.AnimeGroupID];
if (groups.Contains(grp.AnimeGroupID))
{
Contract_AnimeGroup contractGrp = grp.ToContract(userRec);
if (getSingleSeriesGroups)
{
if (contractGrp.Stat_SeriesCount == 1)
{
AnimeSeries ser = GetSeriesForGroup(grp.AnimeGroupID, allSeries);
if (ser != null)
contractGrp.SeriesForNameOverride = ser.ToContract(ser.GetUserRecord(session, userID));
}
}
retGroups.Add(contractGrp);
}
}
}
ts = DateTime.Now - start;
msg = string.Format("Got groups for filter EVAL: {0} - {1} in {2} ms", gf.GroupFilterName, retGroups.Count, ts.TotalMilliseconds);
logger.Info(msg);
return retGroups;
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return retGroups;
}
public List<Contract_GroupFilter> GetAllGroupFilters()
{
List<Contract_GroupFilter> gfs = new List<Contract_GroupFilter>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
DateTime start = DateTime.Now;
GroupFilterRepository repGF = new GroupFilterRepository();
List<GroupFilter> allGfs = repGF.GetAll(session);
TimeSpan ts = DateTime.Now - start;
logger.Info("GetAllGroupFilters (Database) in {0} ms", ts.TotalMilliseconds);
start = DateTime.Now;
foreach (GroupFilter gf in allGfs)
{
gfs.Add(gf.ToContract(session));
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return gfs;
}
private System.IO.Stream GetGroupsFromFilter(int userid, string GroupFilterId, HistoryInfo info)
{
PlexObject ret=new PlexObject(PlexHelper.NewMediaContainer(MediaContainerTypes.Show,info,false));
if (!ret.Init())
return new MemoryStream();
//List<Joint> retGroups = new List<Joint>();
List<Video> retGroups=new List<Video>();
try
{
int groupFilterID ;
int.TryParse(GroupFilterId, out groupFilterID);
using (var session = JMMService.SessionFactory.OpenSession())
{
if (groupFilterID == -1)
return new MemoryStream();
DateTime start = DateTime.Now;
GroupFilterRepository repGF = new GroupFilterRepository();
GroupFilter gf;
if (groupFilterID == -999)
{
// all groups
gf = new GroupFilter();
gf.GroupFilterName = "All";
}
else
{
gf = repGF.GetByID(session, groupFilterID);
if (gf == null) return new MemoryStream();
}
//Contract_GroupFilterExtended contract = gf.ToContractExtended(user);
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
TimeSpan ts = DateTime.Now - start;
string msg = string.Format("Got groups for filter DB: {0} - {1} in {2} ms", gf.GroupFilterName,
allGrps.Count, ts.TotalMilliseconds);
logger.Info(msg);
start = DateTime.Now;
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(userid)) &&
(StatsCache.Instance.StatUserGroupFilter[userid].ContainsKey(gf.GroupFilterID)))
{
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[userid][gf.GroupFilterID];
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
Video v = StatsCache.Instance.StatPlexGroupsCache[userid][grp.AnimeGroupID];
if (v != null)
{
v = v.Clone();
retGroups.Add(v, info);
}
}
}
}
ts = DateTime.Now - start;
msg = string.Format("Got groups for filter EVAL: {0} - {1} in {2} ms", gf.GroupFilterName,
retGroups.Count, ts.TotalMilliseconds);
logger.Info(msg);
if ((groupFilterID == -999) || (gf.SortCriteriaList.Count == 0))
{
ret.Childrens = PlexHelper.ConvertToDirectoryIfNotUnique(retGroups.OrderBy(a => a.Group.SortName).ToList());
return ret.GetStream();
}
List<Contract_AnimeGroup> grps = retGroups.Select(a => a.Group).ToList();
List<SortPropOrFieldAndDirection> sortCriteria = new List<SortPropOrFieldAndDirection>();
foreach (GroupFilterSortingCriteria g in gf.SortCriteriaList)
{
sortCriteria.Add(GroupFilterHelper.GetSortDescription(g.SortType, g.SortDirection));
}
grps = Sorting.MultiSort(grps, sortCriteria);
List<Video> joints2 = new List<Video>();
foreach (Contract_AnimeGroup gr in grps)
{
foreach (Video j in retGroups)
{
if (j.Group == gr)
{
joints2.Add(j);
retGroups.Remove(j);
break;
}
}
}
ret.Childrens = PlexHelper.ConvertToDirectoryIfNotUnique(joints2);
ts = DateTime.Now - start;
msg = string.Format("Got groups final: {0} - {1} in {2} ms", gf.GroupFilterName,
retGroups.Count, ts.TotalMilliseconds);
logger.Info(msg);
return ret.GetStream();
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return new MemoryStream();
}
public System.IO.Stream GetFilters(string uid)
{
int t = 0;
int.TryParse(uid, out t);
JMMUser user = t > 0 ? PlexHelper.GetJMMUser(uid) : PlexHelper.GetUser(uid);
if (user==null)
return new MemoryStream();
int userid = user.JMMUserID;
HistoryInfo info = new HistoryInfo { Key = PlexHelper.ConstructFiltersUrl(userid), Title = "Anime" };
PlexObject ret = new PlexObject(PlexHelper.NewMediaContainer(MediaContainerTypes.Show,info,false));
if (!ret.Init())
return new MemoryStream();
List<Video> dirs = new List<Video>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
List<GroupFilter> allGfs = repGF.GetAll(session);
Dictionary<int, HashSet<int>> gstats = StatsCache.Instance.StatUserGroupFilter[userid];
foreach (GroupFilter gg in allGfs.ToArray())
{
if ((!StatsCache.Instance.StatUserGroupFilter.ContainsKey(userid)) ||
(!StatsCache.Instance.StatUserGroupFilter[userid].ContainsKey(gg.GroupFilterID)))
{
allGfs.Remove(gg);
}
}
AnimeGroupRepository repGroups = new AnimeGroupRepository();
allGfs.Insert(0, new GroupFilter() {GroupFilterName = "All", GroupFilterID = -999});
foreach (GroupFilter gg in allGfs)
{
Random rnd = new Random(123456789);
Directory pp = new Directory { Type="show" };
pp.Key = PlexHelper.ConstructFilterIdUrl(userid, gg.GroupFilterID);
pp.Title = gg.GroupFilterName;
HashSet<int> groups;
groups = gg.GroupFilterID == -999 ? new HashSet<int>(repGroups.GetAllTopLevelGroups(session).Select(a => a.AnimeGroupID)) : gstats[gg.GroupFilterID];
if (groups.Count != 0)
{
bool repeat;
int nn = 0;
pp.LeafCount = groups.Count.ToString();
pp.ViewedLeafCount = "0";
do
{
repeat = true;
int grp = groups.ElementAt(rnd.Next(groups.Count));
AnimeGroup ag = repGroups.GetByID(grp);
List<AnimeSeries> sers = ag.GetSeries(session);
if (sers.Count > 0)
{
AnimeSeries ser = sers[rnd.Next(sers.Count)];
AniDB_Anime anim = ser.GetAnime(session);
if (anim != null)
{
ImageDetails poster = anim.GetDefaultPosterDetailsNoBlanks(session);
ImageDetails fanart = anim.GetDefaultFanartDetailsNoBlanks(session);
if (poster != null)
pp.Thumb = poster.GenPoster();
if (fanart != null)
pp.Art = fanart.GenArt();
if (poster != null)
repeat = false;
}
}
nn++;
if ((repeat) && (nn == 15))
repeat = false;
} while (repeat);
dirs.Add(pp,info);
}
}
VideoLocalRepository repVids = new VideoLocalRepository();
List<VideoLocal> vids = repVids.GetVideosWithoutEpisode();
if (vids.Count > 0)
{
Directory pp = new Directory() { Type = "show" };
pp.Key = PlexHelper.ConstructUnsortUrl(userid);
pp.Title = "Unsort";
pp.Thumb = PlexHelper.ConstructSupportImageLink("plex_unsort.png");
pp.LeafCount = vids.Count.ToString();
pp.ViewedLeafCount = "0";
dirs.Add(pp, info);
}
var repPlaylist = new PlaylistRepository();
var playlists = repPlaylist.GetAll();
if (playlists.Count > 0)
{
Directory pp = new Directory() { Type="show" };
pp.Key = PlexHelper.ConstructPlaylistUrl(userid);
pp.Title = "Playlists";
pp.Thumb = PlexHelper.ConstructSupportImageLink("plex_playlists.png");
pp.LeafCount = playlists.Count.ToString();
pp.ViewedLeafCount = "0";
dirs.Add(pp, info);
}
dirs = dirs.OrderBy(a => a.Title).ToList();
}
ret.Childrens = dirs;
return ret.GetStream();
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return new MemoryStream();
}
}
private static void CreateContinueWatchingGroupFilter()
{
// group filters
GroupFilterRepository repFilters = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
using (var session = JMMService.SessionFactory.OpenSession())
{
// check if it already exists
List<GroupFilter> lockedGFs = repFilters.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gfTemp in lockedGFs)
{
if (gfTemp.FilterType == (int)GroupFilterType.ContinueWatching)
return;
}
// the default value when the column was added to the database was '1'
// this is only needed for users of a migrated database
foreach (GroupFilter gfTemp in lockedGFs)
{
if (gfTemp.GroupFilterName.Equals(Constants.GroupFilterName.ContinueWatching, StringComparison.InvariantCultureIgnoreCase) &&
gfTemp.FilterType != (int)GroupFilterType.ContinueWatching)
{
FixContinueWatchingGroupFilter_20160406();
return;
}
}
}
GroupFilter gf = new GroupFilter();
gf.GroupFilterName = Constants.GroupFilterName.ContinueWatching;
gf.Locked = 1;
gf.SortingCriteria = "4;2"; // by last watched episode desc
gf.ApplyToSeries = 0;
gf.BaseCondition = 1; // all
gf.FilterType = (int)GroupFilterType.ContinueWatching;
repFilters.Save(gf);
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasWatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasUnwatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
}
}
public static void FixContinueWatchingGroupFilter_20160406()
{
// group filters
GroupFilterRepository repFilters = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
using (var session = JMMService.SessionFactory.OpenSession())
{
// check if it already exists
List<GroupFilter> lockedGFs = repFilters.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gf in lockedGFs)
{
if (gf.GroupFilterName.Equals(Constants.GroupFilterName.ContinueWatching, StringComparison.InvariantCultureIgnoreCase))
{
gf.FilterType = (int)GroupFilterType.ContinueWatching;
repFilters.Save(gf);
}
}
}
}
}
private static void CreateContinueWatchingGroupFilter()
{
// group filters
GroupFilterRepository repFilters = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
using (var session = JMMService.SessionFactory.OpenSession())
{
// check if it already exists
List<GroupFilter> lockedGFs = repFilters.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gfTemp in lockedGFs)
if (gfTemp.GroupFilterName.Equals(Constants.GroupFilterName.ContinueWatching, StringComparison.InvariantCultureIgnoreCase)) return;
}
GroupFilter gf = new GroupFilter();
gf.GroupFilterName = Constants.GroupFilterName.ContinueWatching;
gf.Locked = 1;
gf.SortingCriteria = "4;2"; // by last watched episode desc
gf.ApplyToSeries = 0;
gf.BaseCondition = 1; // all
repFilters.Save(gf);
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasWatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasUnwatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
}
}
public List<MetroContract_Anime_Summary> GetAnimeContinueWatching(int maxRecords, int jmmuserID)
{
List<MetroContract_Anime_Summary> retAnime = new List<MetroContract_Anime_Summary>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(session, jmmuserID);
if (user == null) return retAnime;
// find the locked Continue Watching Filter
GroupFilter gf = null;
List<GroupFilter> lockedGFs = repGF.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gfTemp in lockedGFs)
{
if (gfTemp.GroupFilterName.Equals(Constants.GroupFilterName.ContinueWatching, StringComparison.InvariantCultureIgnoreCase))
{
gf = gfTemp;
break;
}
}
}
if (gf == null) return retAnime;
// Get all the groups
// it is more efficient to just get the full list of groups and then filter them later
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
// get all the user records
AnimeGroup_UserRepository repUserRecords = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecords = repUserRecords.GetByUserID(session, jmmuserID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User userRec in userRecords)
dictUserRecords[userRec.AnimeGroupID] = userRec;
// get all the groups in this filter for this user
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[user.JMMUserID][gf.GroupFilterID];
List<Contract_AnimeGroup> comboGroups = new List<Contract_AnimeGroup>();
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(grp.AnimeGroupID)) userRec = dictUserRecords[grp.AnimeGroupID];
Contract_AnimeGroup rec = grp.ToContract(userRec);
comboGroups.Add(rec);
}
}
// apply sorting
List<SortPropOrFieldAndDirection> sortCriteria = GroupFilterHelper.GetSortDescriptions(gf);
comboGroups = Sorting.MultiSort<Contract_AnimeGroup>(comboGroups, sortCriteria);
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(user.JMMUserID)) && (StatsCache.Instance.StatUserGroupFilter[user.JMMUserID].ContainsKey(gf.GroupFilterID)))
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (Contract_AnimeGroup grp in comboGroups)
{
JMMServiceImplementation imp = new JMMServiceImplementation();
foreach (AnimeSeries ser in repSeries.GetByGroupID(session, grp.AnimeGroupID))
{
if (!user.AllowedSeries(ser)) continue;
AnimeSeries_User serUser = ser.GetUserRecord(session, jmmuserID);
Contract_AnimeEpisode ep = imp.GetNextUnwatchedEpisode(session, ser.AnimeSeriesID, jmmuserID);
if (ep != null)
{
AniDB_Anime anidb_anime = ser.GetAnime(session);
MetroContract_Anime_Summary summ = new MetroContract_Anime_Summary();
summ.AnimeID = ser.AniDB_ID;
summ.AnimeName = ser.GetSeriesName(session);
summ.AnimeSeriesID = ser.AnimeSeriesID;
summ.BeginYear = anidb_anime.BeginYear;
summ.EndYear = anidb_anime.EndYear;
//summ.PosterName = anidb_anime.GetDefaultPosterPathNoBlanks(session);
if (serUser != null)
summ.UnwatchedEpisodeCount = serUser.UnwatchedEpisodeCount;
else
summ.UnwatchedEpisodeCount = 0;
ImageDetails imgDet = anidb_anime.GetDefaultPosterDetailsNoBlanks(session);
summ.ImageType = (int)imgDet.ImageType;
summ.ImageID = imgDet.ImageID;
retAnime.Add(summ);
// Lets only return the specified amount
if (retAnime.Count == maxRecords) return retAnime;
}
else
logger.Info(string.Format("GetAnimeContinueWatching:Skipping Anime - no episodes: {0}", ser.AniDB_ID));
}
}
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return retAnime;
}
public System.IO.Stream GetFilters(string uid)
{
JMMUser user = KodiHelper.GetUser(uid);
if (user==null)
return new MemoryStream();
int userid = user.JMMUserID;
KodiObject ret =new KodiObject(KodiHelper.NewMediaContainer("Anime", false));
if (!ret.Init())
return new MemoryStream();
List<Video> dirs = new List<Video>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
List<GroupFilter> allGfs = repGF.GetAll(session);
Dictionary<int, HashSet<int>> gstats = StatsCache.Instance.StatUserGroupFilter[userid];
foreach (GroupFilter gg in allGfs.ToArray())
{
if ((!StatsCache.Instance.StatUserGroupFilter.ContainsKey(userid)) ||
(!StatsCache.Instance.StatUserGroupFilter[userid].ContainsKey(gg.GroupFilterID)))
{
allGfs.Remove(gg);
}
}
AnimeGroupRepository repGroups = new AnimeGroupRepository();
allGfs.Insert(0, new GroupFilter() {GroupFilterName = "All", GroupFilterID = -999});
foreach (GroupFilter gg in allGfs)
{
Random rnd = new Random(123456789);
Directory pp = new Directory();
pp.Key = KodiHelper.ServerUrl(int.Parse(ServerSettings.JMMServerPort),
MainWindow.PathAddressKodi + "/GetMetadata/" + userid + "/" +
(int) JMMType.GroupFilter + "/" + gg.GroupFilterID);
pp.PrimaryExtraKey = pp.Key;
pp.Title = gg.GroupFilterName;
HashSet<int> groups;
groups = gg.GroupFilterID == -999 ? new HashSet<int>(repGroups.GetAllTopLevelGroups(session).Select(a => a.AnimeGroupID)) : gstats[gg.GroupFilterID];
if (groups.Count != 0)
{
bool repeat;
int nn = 0;
pp.LeafCount = groups.Count.ToString();
pp.ViewedLeafCount = "0";
do
{
repeat = true;
int grp = groups.ElementAt(rnd.Next(groups.Count));
AnimeGroup ag = repGroups.GetByID(grp);
List<AnimeSeries> sers = ag.GetSeries(session);
if (sers.Count > 0)
{
AnimeSeries ser = sers[rnd.Next(sers.Count)];
AniDB_Anime anim = ser.GetAnime(session);
if (anim != null)
{
ImageDetails poster = anim.GetDefaultPosterDetailsNoBlanks(session);
ImageDetails fanart = anim.GetDefaultFanartDetailsNoBlanks(session);
if (poster != null)
pp.Thumb = poster.GenPoster();
if (fanart != null)
pp.Art = fanart.GenArt();
if (poster != null)
repeat = false;
}
}
nn++;
if ((repeat) && (nn == 15))
repeat = false;
} while (repeat);
dirs.Add(pp);
}
}
VideoLocalRepository repVids = new VideoLocalRepository();
List<VideoLocal> vids = repVids.GetVideosWithoutEpisode();
if (vids.Count > 0)
{
JMMContracts.KodiContracts.Directory pp = new JMMContracts.KodiContracts.Directory();
pp.Key = pp.PrimaryExtraKey = KodiHelper.ServerUrl(int.Parse(ServerSettings.JMMServerPort),
MainWindow.PathAddressKodi + "/GetMetadata/0/" + (int) JMMType.GroupUnsort + "/0");
pp.Title = "Unsort";
pp.Thumb = KodiHelper.ServerUrl(int.Parse(ServerSettings.JMMServerPort),
MainWindow.PathAddressKodi + "/GetSupportImage/plex_unsort.png");
pp.LeafCount = vids.Count.ToString();
pp.ViewedLeafCount = "0";
dirs.Add(pp);
}
dirs = dirs.OrderBy(a => a.Title).ToList();
}
ret.Childrens = dirs;
return ret.GetStream();
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return new MemoryStream();
}
}
public List<Contract_GroupFilterExtended> GetAllGroupFiltersExtended(int userID)
{
List<Contract_GroupFilterExtended> gfs = new List<Contract_GroupFilterExtended>();
try
{
DateTime start = DateTime.Now;
GroupFilterRepository repGF = new GroupFilterRepository();
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(userID);
if (user == null) return gfs;
List<GroupFilter> allGfs = repGF.GetAll();
TimeSpan ts = DateTime.Now - start;
logger.Info("GetAllGroupFilters (Database) in {0} ms", ts.TotalMilliseconds);
start = DateTime.Now;
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAllTopLevelGroups();
ts = DateTime.Now - start;
logger.Info("GetAllGroups (Database) in {0} ms", ts.TotalMilliseconds);
start = DateTime.Now;
foreach (GroupFilter gf in allGfs)
{
Contract_GroupFilter gfContract = gf.ToContract();
Contract_GroupFilterExtended gfeContract = new Contract_GroupFilterExtended();
gfeContract.GroupFilter = gfContract;
gfeContract.GroupCount = 0;
gfeContract.SeriesCount = 0;
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(user.JMMUserID)) && (StatsCache.Instance.StatUserGroupFilter[userID].ContainsKey(gf.GroupFilterID)))
{
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[user.JMMUserID][gf.GroupFilterID];
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
// calculate stats
gfeContract.GroupCount++;
}
}
}
gfs.Add(gfeContract);
}
ts = DateTime.Now - start;
logger.Info("GetAllGroupFiltersExtended (FILTER) in {0} ms", ts.TotalMilliseconds);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return gfs;
}
private System.IO.Stream GetGroupsFromFilter(int userid, string GroupFilterId)
{
KodiObject ret=new KodiObject(KodiHelper.NewMediaContainer("Filters",true));
if (!ret.Init())
return new MemoryStream();
//List<Joint> retGroups = new List<Joint>();
List<Video> retGroups=new List<Video>();
try
{
int groupFilterID ;
int.TryParse(GroupFilterId, out groupFilterID);
using (var session = JMMService.SessionFactory.OpenSession())
{
if (groupFilterID == -1)
return new MemoryStream();
DateTime start = DateTime.Now;
GroupFilterRepository repGF = new GroupFilterRepository();
GroupFilter gf;
if (groupFilterID == -999)
{
// all groups
gf = new GroupFilter();
gf.GroupFilterName = "All";
}
else
{
gf = repGF.GetByID(session, groupFilterID);
if (gf == null) return new MemoryStream();
}
ret.MediaContainer.Title2 = ret.MediaContainer.Title1 = gf.GroupFilterName;
//Contract_GroupFilterExtended contract = gf.ToContractExtended(user);
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
TimeSpan ts = DateTime.Now - start;
string msg = string.Format("Got groups for filter DB: {0} - {1} in {2} ms", gf.GroupFilterName,
allGrps.Count, ts.TotalMilliseconds);
logger.Info(msg);
start = DateTime.Now;
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(userid)) &&
(StatsCache.Instance.StatUserGroupFilter[userid].ContainsKey(gf.GroupFilterID)))
{
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[userid][gf.GroupFilterID];
var tas = StatsCache.Instance.StatKodiGroupsCache;
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
try {
//if (grp.GroupName == "Rockman.EXE")
//{
// int x = grp.MissingEpisodeCount;
//}
Video v = StatsCache.Instance.StatKodiGroupsCache[userid][grp.AnimeGroupID];
if (v != null)
{
//proper naming
AniDB_Anime anim = grp.Anime[0];
v.OriginalTitle = "";
foreach (AniDB_Anime_Title title in anim.GetTitles())
{
if (title.TitleType == "official" || title.TitleType == "main")
{
v.OriginalTitle += "{" + title.TitleType + ":" + title.Language + "}" + title.Title + "|";
}
}
v.OriginalTitle = v.OriginalTitle.Substring(0, v.OriginalTitle.Length - 1);
//proper naming end
retGroups.Add(v.Clone());
}
}
catch(Exception e)
{
int x = retGroups.Count;
}
}
}
}
ts = DateTime.Now - start;
msg = string.Format("Got groups for filter EVAL: {0} - {1} in {2} ms", gf.GroupFilterName,
retGroups.Count, ts.TotalMilliseconds);
logger.Info(msg);
if ((groupFilterID == -999) || (gf.SortCriteriaList.Count == 0))
{
ret.Childrens = retGroups.OrderBy(a => a.Group.SortName).ToList();
return ret.GetStream();
}
List<Contract_AnimeGroup> grps = retGroups.Select(a => a.Group).ToList();
List<SortPropOrFieldAndDirection> sortCriteria = new List<SortPropOrFieldAndDirection>();
foreach (GroupFilterSortingCriteria g in gf.SortCriteriaList)
{
sortCriteria.Add(GroupFilterHelper.GetSortDescription(g.SortType, g.SortDirection));
}
grps = Sorting.MultiSort(grps, sortCriteria);
List<Video> joints2 = new List<Video>();
foreach (Contract_AnimeGroup gr in grps)
{
foreach (Video j in retGroups)
{
if (j.Group == gr)
{
//experiment
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeGroup ag = repGroups.GetByID(gr.AnimeGroupID);
List<AnimeSeries> sers = ag.GetAllSeries();
AnimeSeries ser = sers[0];
AniDB_Anime anim = ser.GetAnime();
j.CharactersList = new List<Characters>();
Characters c = new Characters();
c.CharactersList = GetCharactersFromAniDB(anim);
j.CharactersList.Add(c);
//experimentEND
//proper naming
j.OriginalTitle = "";
foreach (AniDB_Anime_Title title in anim.GetTitles())
{
if (title.TitleType == "official" || title.TitleType == "main")
{
j.OriginalTitle += "{" + title.TitleType + ":" + title.Language + "}" + title.Title + "|";
}
}
j.OriginalTitle = j.OriginalTitle.Substring(0, j.OriginalTitle.Length - 1);
//proper naming end
//community support
//CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
//List<CrossRef_AniDB_TraktV2> Trakt = repCrossRef.GetByAnimeID(anim.AnimeID);
//if (Trakt != null)
//{
// if (Trakt.Count > 0)
// {
// j.Trakt = Trakt[0].TraktID;
// }
//}
//CrossRef_AniDB_TvDBV2Repository repCrossRefV2 = new CrossRef_AniDB_TvDBV2Repository();
//List<CrossRef_AniDB_TvDBV2> TvDB = repCrossRefV2.GetByAnimeID(anim.AnimeID);
//if (TvDB != null)
//{
// if (TvDB.Count > 0)
// {
// j.TvDB = TvDB[0].TvDBID.ToString();
// }
//}
//community support END
joints2.Add(j);
retGroups.Remove(j);
break;
}
}
}
ret.Childrens = joints2;
ret.MediaContainer.Art = KodiHelper.GetRandomFanartFromVideoList(ret.Childrens);
ts = DateTime.Now - start;
msg = string.Format("Got groups final: {0} - {1} in {2} ms", gf.GroupFilterName,
retGroups.Count, ts.TotalMilliseconds);
logger.Info(msg);
return ret.GetStream();
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return new MemoryStream();
}
public List<Contract_AnimeEpisode> GetContinueWatchingFilter(int userID, int maxRecords)
{
List<Contract_AnimeEpisode> retEps = new List<Contract_AnimeEpisode>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(session, userID);
if (user == null) return retEps;
// find the locked Continue Watching Filter
GroupFilter gf = null;
List<GroupFilter> lockedGFs = repGF.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gfTemp in lockedGFs)
{
if (gfTemp.FilterType == (int)GroupFilterType.ContinueWatching)
{
gf = gfTemp;
break;
}
}
}
if (gf == null) return retEps;
// Get all the groups
// it is more efficient to just get the full list of groups and then filter them later
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
// get all the user records
AnimeGroup_UserRepository repUserRecords = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecords = repUserRecords.GetByUserID(session, userID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User userRec in userRecords)
dictUserRecords[userRec.AnimeGroupID] = userRec;
// get all the groups in this filter for this user
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[user.JMMUserID][gf.GroupFilterID];
List<Contract_AnimeGroup> comboGroups = new List<Contract_AnimeGroup>();
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(grp.AnimeGroupID)) userRec = dictUserRecords[grp.AnimeGroupID];
Contract_AnimeGroup rec = grp.ToContract(userRec);
comboGroups.Add(rec);
}
}
// apply sorting
List<SortPropOrFieldAndDirection> sortCriteria = GroupFilterHelper.GetSortDescriptions(gf);
comboGroups = Sorting.MultiSort<Contract_AnimeGroup>(comboGroups, sortCriteria);
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(user.JMMUserID)) && (StatsCache.Instance.StatUserGroupFilter[user.JMMUserID].ContainsKey(gf.GroupFilterID)))
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (Contract_AnimeGroup grp in comboGroups)
{
List<AnimeSeries> sers = repSeries.GetByGroupID(session, grp.AnimeGroupID);
// sort the series by air date
List<SortPropOrFieldAndDirection> sortCriteria2 = new List<SortPropOrFieldAndDirection>();
sortCriteria2.Add(new SortPropOrFieldAndDirection("AirDate", false, SortType.eDateTime));
sers = Sorting.MultiSort<AnimeSeries>(sers, sortCriteria2);
List<int> seriesWatching = new List<int>();
foreach (AnimeSeries ser in sers)
{
if (!user.AllowedSeries(ser)) continue;
bool useSeries = true;
if (seriesWatching.Count > 0)
{
if (ser.GetAnime().AnimeType == (int)enAnimeType.TVSeries)
{
// make sure this series is not a sequel to an existing series we have already added
foreach (AniDB_Anime_Relation rel in ser.GetAnime().GetRelatedAnime())
{
if (rel.RelationType.ToLower().Trim().Equals("sequel") || rel.RelationType.ToLower().Trim().Equals("prequel"))
useSeries = false;
}
}
}
if (!useSeries) continue;
Contract_AnimeEpisode ep = GetNextUnwatchedEpisode(session, ser.AnimeSeriesID, userID);
if (ep != null)
{
retEps.Add(ep);
// Lets only return the specified amount
if (retEps.Count == maxRecords)
return retEps;
if (ser.GetAnime().AnimeType == (int)enAnimeType.TVSeries)
seriesWatching.Add(ser.AniDB_ID);
}
}
}
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return retEps;
}
public List<Contract_AnimeEpisode> GetContinueWatchingFilter(int userID, int maxRecords)
{
List<Contract_AnimeEpisode> retEps = new List<Contract_AnimeEpisode>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser user = repUsers.GetByID(session, userID);
if (user == null) return retEps;
// find the locked Continue Watching Filter
GroupFilter gf = null;
List<GroupFilter> lockedGFs = repGF.GetLockedGroupFilters(session);
if (lockedGFs != null)
{
// if it already exists we can leave
foreach (GroupFilter gfTemp in lockedGFs)
{
if (gfTemp.GroupFilterName.Equals(Constants.GroupFilterName.ContinueWatching, StringComparison.InvariantCultureIgnoreCase))
{
gf = gfTemp;
break;
}
}
}
if (gf == null) return retEps;
// Get all the groups
// it is more efficient to just get the full list of groups and then filter them later
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
// get all the user records
AnimeGroup_UserRepository repUserRecords = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecords = repUserRecords.GetByUserID(session, userID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User userRec in userRecords)
dictUserRecords[userRec.AnimeGroupID] = userRec;
// get all the groups in this filter for this user
HashSet<int> groups = StatsCache.Instance.StatUserGroupFilter[user.JMMUserID][gf.GroupFilterID];
List<Contract_AnimeGroup> comboGroups = new List<Contract_AnimeGroup>();
foreach (AnimeGroup grp in allGrps)
{
if (groups.Contains(grp.AnimeGroupID))
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(grp.AnimeGroupID)) userRec = dictUserRecords[grp.AnimeGroupID];
Contract_AnimeGroup rec = grp.ToContract(userRec);
comboGroups.Add(rec);
}
}
// apply sorting
List<SortPropOrFieldAndDirection> sortCriteria = GroupFilterHelper.GetSortDescriptions(gf);
comboGroups = Sorting.MultiSort<Contract_AnimeGroup>(comboGroups, sortCriteria);
if ((StatsCache.Instance.StatUserGroupFilter.ContainsKey(user.JMMUserID)) && (StatsCache.Instance.StatUserGroupFilter[user.JMMUserID].ContainsKey(gf.GroupFilterID)))
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (Contract_AnimeGroup grp in comboGroups)
{
foreach (AnimeSeries ser in repSeries.GetByGroupID(session, grp.AnimeGroupID))
{
if (!user.AllowedSeries(ser)) continue;
Contract_AnimeEpisode ep = GetNextUnwatchedEpisode(session, ser.AnimeSeriesID, userID);
if (ep != null)
{
retEps.Add(ep);
// Lets only return the specified amount
if (retEps.Count == maxRecords)
return retEps;
}
}
}
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return retEps;
}
public Contract_GroupFilter_SaveResponse SaveGroupFilter(Contract_GroupFilter contract)
{
Contract_GroupFilter_SaveResponse response = new Contract_GroupFilter_SaveResponse();
response.ErrorMessage = string.Empty;
response.GroupFilter = null;
GroupFilterRepository repGF = new GroupFilterRepository();
GroupFilterConditionRepository repGFC = new GroupFilterConditionRepository();
// Process the group
GroupFilter gf = null;
if (contract.GroupFilterID.HasValue)
{
gf = repGF.GetByID(contract.GroupFilterID.Value);
if (gf == null)
{
response.ErrorMessage = "Could not find existing Group Filter with ID: " + contract.GroupFilterID.Value.ToString();
return response;
}
}
else
gf = new GroupFilter();
gf.GroupFilterName = contract.GroupFilterName;
gf.ApplyToSeries = contract.ApplyToSeries;
gf.BaseCondition = contract.BaseCondition;
gf.SortingCriteria = contract.SortingCriteria;
if (string.IsNullOrEmpty(gf.GroupFilterName))
{
response.ErrorMessage = "Must specify a group filter name";
return response;
}
repGF.Save(gf);
// Process the filter conditions
// check for any that have been deleted
foreach (GroupFilterCondition gfc in gf.FilterConditions)
{
bool gfcExists = false;
foreach (Contract_GroupFilterCondition gfc_con in contract.FilterConditions)
{
if (gfc_con.GroupFilterConditionID.HasValue && gfc_con.GroupFilterConditionID.Value == gfc.GroupFilterConditionID)
{
gfcExists = true;
break;
}
}
if (!gfcExists)
repGFC.Delete(gfc.GroupFilterConditionID);
}
// save newly added or modified ones
foreach (Contract_GroupFilterCondition gfc_con in contract.FilterConditions)
{
GroupFilterCondition gfc = null;
if (gfc_con.GroupFilterConditionID.HasValue)
{
gfc = repGFC.GetByID(gfc_con.GroupFilterConditionID.Value);
if (gfc == null)
{
response.ErrorMessage = "Could not find existing Group Filter Condition with ID: " + gfc_con.GroupFilterConditionID.ToString();
return response;
}
}
else
gfc = new GroupFilterCondition();
gfc.ConditionOperator = gfc_con.ConditionOperator;
gfc.ConditionParameter = gfc_con.ConditionParameter;
gfc.ConditionType = gfc_con.ConditionType;
gfc.GroupFilterID = gf.GroupFilterID;
repGFC.Save(gfc);
}
response.GroupFilter = gf.ToContract();
return response;
}
public void UpdateGroupFilterUsingUser(int userid)
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
JMMUserRepository repUser = new JMMUserRepository();
GroupFilterRepository repGrpFilter = new GroupFilterRepository();
JMMUser user = repUser.GetByID(userid);
if (user == null)
return;
Dictionary<int, HashSet<int>> groupfilters;
if (StatUserGroupFilter.ContainsKey(user.JMMUserID))
groupfilters = StatUserGroupFilter[user.JMMUserID];
else
{
groupfilters = new Dictionary<int, HashSet<int>>();
StatUserGroupFilter.Add(user.JMMUserID, groupfilters);
}
List<GroupFilter> gfs = repGrpFilter.GetAll();
GroupFilter gfgf = new GroupFilter();
gfgf.GroupFilterName = "All";
gfs.Add(gfgf);
foreach(GroupFilter gf in gfs)
{
HashSet<int> groups;
if (groupfilters.ContainsKey(gf.GroupFilterID))
groups = groupfilters[gf.GroupFilterID];
else
{
groups = new HashSet<int>();
groupfilters.Add(gf.GroupFilterID, groups);
}
groups.Clear();
List<AnimeGroup> allGrps = repGroups.GetAllTopLevelGroups(); // No Need of subgroups
foreach (AnimeGroup grp in allGrps)
{
AnimeGroup_User userRec = repUserGroups.GetByUserAndGroupID(user.JMMUserID, grp.AnimeGroupID);
if (EvaluateGroupFilter(gf, grp, user, userRec))
groups.Add(grp.AnimeGroupID);
}
}
}
public void Save(AnimeSeries obj, bool updateGroups, bool onlyupdatestats, bool skipgroupfilters = false)
{
bool newSeries = false;
AnimeGroup oldGroup = null;
AnimeGroupRepository repGroups = new AnimeGroupRepository();
bool isMigrating = false;
lock (obj)
{
if (obj.AnimeSeriesID == 0)
{
newSeries = true; // a new series
}
else
{
// get the old version from the DB
AnimeSeries oldSeries;
using (var session = JMMService.SessionFactory.OpenSession())
{
oldSeries = session.Get <AnimeSeries>(obj.AnimeSeriesID);
}
if (oldSeries != null)
{
// means we are moving series to a different group
if (oldSeries.AnimeGroupID != obj.AnimeGroupID)
{
oldGroup = repGroups.GetByID(oldSeries.AnimeGroupID);
AnimeGroup newGroup = repGroups.GetByID(obj.AnimeGroupID);
if (newGroup != null && newGroup.GroupName.Equals("AAA Migrating Groups AAA"))
{
isMigrating = true;
}
newSeries = true;
}
}
}
if (newSeries && !isMigrating)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
obj.Contract = null;
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
HashSet <GroupFilterConditionType> types = obj.UpdateContract(onlyupdatestats);
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
if (!skipgroupfilters && !isMigrating)
{
GroupFilterRepository.CreateOrVerifyTagsAndYearsFilters(false,
obj.Contract?.AniDBAnime?.AniDBAnime?.AllTags, obj.Contract?.AniDBAnime?.AniDBAnime?.AirDate);
//This call will create extra years or tags if the Group have a new year or tag
obj.UpdateGroupFilters(types, null);
}
Cache.Update(obj);
Changes.AddOrUpdate(obj.AnimeSeriesID);
}
if (updateGroups && !isMigrating)
{
if (newSeries)
{
logger.Trace("Updating group stats by series from AnimeSeriesRepository.Save: {0}",
obj.AnimeSeriesID);
AnimeGroup grp = repGroups.GetByID(obj.AnimeGroupID);
if (grp != null)
{
repGroups.Save(grp, true, true);
}
}
if (oldGroup != null)
{
logger.Trace("Updating group stats by group from AnimeSeriesRepository.Save: {0}",
oldGroup.AnimeGroupID);
repGroups.Save(oldGroup, true, true);
}
}
}
//TODO Cleanup function for Empty Tags and Empty Years
public static void CreateOrVerifyLockedFilters()
{
GroupFilterRepository repFilters = new GroupFilterRepository();
using (var session = JMMService.SessionFactory.OpenSession())
{
string t = "GroupFilter";
List <GroupFilter> lockedGFs = repFilters.GetLockedGroupFilters(session);
//Continue Watching
// check if it already exists
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, " " + Properties.Resources.Filter_CreateContinueWatching);
GroupFilter cwatching =
lockedGFs.FirstOrDefault(
a =>
a.FilterType == (int)GroupFilterType.ContinueWatching);
if (cwatching != null && cwatching.FilterType != (int)GroupFilterType.ContinueWatching)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, " " + Properties.Resources.Filter_CreateContinueWatching);
cwatching.FilterType = (int)GroupFilterType.ContinueWatching;
repFilters.Save(cwatching);
}
else if (cwatching == null)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, " " + Properties.Resources.Filter_CreateContinueWatching);
GroupFilter gf = new GroupFilter();
gf.GroupFilterName = Constants.GroupFilterName.ContinueWatching;
gf.Locked = 1;
gf.SortingCriteria = "4;2"; // by last watched episode desc
gf.ApplyToSeries = 0;
gf.BaseCondition = 1; // all
gf.FilterType = (int)GroupFilterType.ContinueWatching;
gf.InvisibleInClients = 0;
gf.Conditions = new List <GroupFilterCondition>();
GroupFilterCondition gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasWatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
gf.Conditions.Add(gfc);
gfc = new GroupFilterCondition();
gfc.ConditionType = (int)GroupFilterConditionType.HasUnwatchedEpisodes;
gfc.ConditionOperator = (int)GroupFilterOperator.Include;
gfc.ConditionParameter = "";
gfc.GroupFilterID = gf.GroupFilterID;
gf.Conditions.Add(gfc);
gf.EvaluateAnimeGroups();
gf.EvaluateAnimeSeries();
repFilters.Save(gf); //Get ID
}
//Create All filter
GroupFilter allfilter = lockedGFs.FirstOrDefault(a => a.FilterType == (int)GroupFilterType.All);
if (allfilter == null)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, " " + Properties.Resources.Filter_CreateAll);
GroupFilter gf = new GroupFilter
{
GroupFilterName = Properties.Resources.Filter_All,
Locked = 1,
InvisibleInClients = 0,
FilterType = (int)GroupFilterType.All,
BaseCondition = 1,
SortingCriteria = "5;1"
};
gf.EvaluateAnimeGroups();
gf.EvaluateAnimeSeries();
repFilters.Save(gf);
}
GroupFilter tagsdirec =
lockedGFs.FirstOrDefault(
a => a.FilterType == (int)(GroupFilterType.Directory | GroupFilterType.Tag));
if (tagsdirec == null)
{
tagsdirec = new GroupFilter
{
GroupFilterName = Properties.Resources.Filter_Tags,
InvisibleInClients = 0,
FilterType = (int)(GroupFilterType.Directory | GroupFilterType.Tag),
BaseCondition = 1,
Locked = 1,
SortingCriteria = "13;1"
};
repFilters.Save(tagsdirec);
}
GroupFilter yearsdirec =
lockedGFs.FirstOrDefault(
a => a.FilterType == (int)(GroupFilterType.Directory | GroupFilterType.Year));
if (yearsdirec == null)
{
yearsdirec = new GroupFilter
{
GroupFilterName = Properties.Resources.Filter_Years,
InvisibleInClients = 0,
FilterType = (int)(GroupFilterType.Directory | GroupFilterType.Year),
BaseCondition = 1,
Locked = 1,
SortingCriteria = "13;1"
};
repFilters.Save(yearsdirec);
}
}
CreateOrVerifyTagsAndYearsFilters(true);
}
