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;
}
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 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;
}
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);
}
}
}
}
}
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);
}
}
}
}
//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);
}
