public static void InitCache()
{
string t = "AnimeGroups_User";
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, string.Empty);
AnimeGroup_UserRepository repo = new AnimeGroup_UserRepository();
Cache = new PocoCache <int, AnimeGroup_User>(repo.InternalGetAll(), a => a.AnimeGroup_UserID);
Groups = Cache.CreateIndex(a => a.AnimeGroupID);
Users = Cache.CreateIndex(a => a.JMMUserID);
UsersGroups = Cache.CreateIndex(a => a.JMMUserID, a => a.AnimeGroupID);
foreach (int n in Cache.Values.Select(a => a.JMMUserID).Distinct())
{
Changes[n] = new ChangeTracker <int>();
Changes[n].AddOrUpdateRange(Users.GetMultiple(n).Select(a => a.AnimeGroupID));
}
int cnt = 0;
List <AnimeGroup_User> grps =
Cache.Values.Where(a => a.PlexContractVersion < AnimeGroup_User.PLEXCONTRACT_VERSION).ToList();
int max = grps.Count;
foreach (AnimeGroup_User g in grps)
{
repo.Save(g);
cnt++;
if (cnt % 10 == 0)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
" DbRegen - " + cnt + "/" + max);
}
}
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
" DbRegen - " + max + "/" + max);
}
public void Delete(int id)
{
AnimeGroup cr = GetByID(id);
if (cr != null)
{
// delete user records
AnimeGroup_UserRepository repUsers = new AnimeGroup_UserRepository();
foreach (AnimeGroup_User grpUser in repUsers.GetByGroupID(id))
{
repUsers.Delete(grpUser.AnimeGroup_UserID);
}
cr.DeleteFromFilters();
Cache.Remove(cr);
Changes.Remove(cr.AnimeGroupID);
}
int parentID = 0;
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
if (cr != null)
{
if (cr.AnimeGroupParentID.HasValue)
{
parentID = cr.AnimeGroupParentID.Value;
}
session.Delete(cr);
transaction.Commit();
}
}
}
if (parentID > 0)
{
logger.Trace("Updating group stats by group from AnimeGroupRepository.Delete: {0}", parentID);
AnimeGroup ngrp = GetByID(parentID);
if (ngrp != null)
{
this.Save(ngrp, false, true);
}
}
}
public List<Contract_AnimeGroup> GetAllGroups(int userID)
{
List<Contract_AnimeGroup> grps = new List<Contract_AnimeGroup>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
DateTime start = DateTime.Now;
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
TimeSpan ts = DateTime.Now - start;
logger.Info("GetAllGroups (Database) in {0} ms", ts.TotalMilliseconds);
start = DateTime.Now;
// user records
AnimeGroup_UserRepository repGroupUser = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecordList = repGroupUser.GetByUserID(session, userID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User grpUser in userRecordList)
dictUserRecords[grpUser.AnimeGroupID] = grpUser;
foreach (AnimeGroup ag in allGrps)
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(ag.AnimeGroupID))
userRec = dictUserRecords[ag.AnimeGroupID];
// calculate stats
Contract_AnimeGroup contract = ag.ToContract(userRec);
grps.Add(contract);
}
grps.Sort();
ts = DateTime.Now - start;
logger.Info("GetAllGroups (Contracts) in {0} ms", ts.TotalMilliseconds);
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return grps;
}
public void Delete(int id)
{
AnimeGroup cr = GetByID(id);
if (cr != null)
{
// delete user records
AnimeGroup_UserRepository repUsers = new AnimeGroup_UserRepository();
foreach (AnimeGroup_User grpUser in repUsers.GetByGroupID(id))
{
repUsers.Delete(grpUser.AnimeGroup_UserID);
}
}
int parentID = 0;
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
if (cr != null)
{
if (cr.AnimeGroupParentID.HasValue)
{
parentID = cr.AnimeGroupParentID.Value;
}
session.Delete(cr);
transaction.Commit();
}
}
}
if (parentID > 0)
{
logger.Trace("Updating group stats by group from AnimeGroupRepository.Delete: {0}", parentID);
StatsCache.Instance.UpdateUsingGroup(parentID);
}
}
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_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<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_AnimeGroup> GetAllGroups(int userID)
{
List<Contract_AnimeGroup> grps = new List<Contract_AnimeGroup>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
List<AnimeGroup> allGrps = repGroups.GetAll(session);
// user records
AnimeGroup_UserRepository repGroupUser = new AnimeGroup_UserRepository();
List<AnimeGroup_User> userRecordList = repGroupUser.GetByUserID(session, userID);
Dictionary<int, AnimeGroup_User> dictUserRecords = new Dictionary<int, AnimeGroup_User>();
foreach (AnimeGroup_User grpUser in userRecordList)
dictUserRecords[grpUser.AnimeGroupID] = grpUser;
foreach (AnimeGroup ag in allGrps)
{
AnimeGroup_User userRec = null;
if (dictUserRecords.ContainsKey(ag.AnimeGroupID))
userRec = dictUserRecords[ag.AnimeGroupID];
// calculate stats
Contract_AnimeGroup contract = ag.ToContract(userRec);
contract.ServerPosterPath = ag.GetPosterPathNoBlanks(session);
grps.Add(contract);
}
grps.Sort();
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return grps;
}
public string DeleteUser(int userID)
{
JMMUserRepository repUsers = new JMMUserRepository();
try
{
JMMUser jmmUser = repUsers.GetByID(userID);
if (jmmUser == null) return "User not found";
// make sure that at least one user is an admin
if (jmmUser.IsAdmin == 1)
{
bool adminExists = false;
List<JMMUser> users = repUsers.GetAll();
foreach (JMMUser userOld in users)
{
if (userOld.IsAdmin == 1)
{
if (userOld.JMMUserID != jmmUser.JMMUserID) adminExists = true;
}
}
if (!adminExists) return "At least one user must be an administrator";
}
repUsers.Delete(userID);
// delete all user records
AnimeSeries_UserRepository repSeries = new AnimeSeries_UserRepository();
foreach (AnimeSeries_User ser in repSeries.GetByUserID(userID))
repSeries.Delete(ser.AnimeSeries_UserID);
AnimeGroup_UserRepository repGroup = new AnimeGroup_UserRepository();
foreach (AnimeGroup_User grp in repGroup.GetByUserID(userID))
repGroup.Delete(grp.AnimeGroup_UserID);
AnimeEpisode_UserRepository repEpisode = new AnimeEpisode_UserRepository();
foreach (AnimeEpisode_User ep in repEpisode.GetByUserID(userID))
repEpisode.Delete(ep.AnimeEpisode_UserID);
VideoLocal_UserRepository repVids = new VideoLocal_UserRepository();
foreach (VideoLocal_User vid in repVids.GetByUserID(userID))
repVids.Delete(vid.VideoLocal_UserID);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
return "";
}
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 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 UpdatePlexAnimeGroup(ISession session, AnimeGroup grp, List<AnimeSeries> allSeries)
{
JMMUserRepository repUser = new JMMUserRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
foreach (JMMUser user in repUser.GetAll(session))
{
AnimeGroup_User userRec = repUserGroups.GetByUserAndGroupID(session, user.JMMUserID, grp.AnimeGroupID);
Dictionary<int, Video> cdic;
if (StatPlexGroupsCache.ContainsKey(user.JMMUserID))
cdic = StatPlexGroupsCache[user.JMMUserID];
else
{
cdic = new Dictionary<int, Video>();
StatPlexGroupsCache[user.JMMUserID] = cdic;
}
cdic[grp.AnimeGroupID]=JMMServiceImplementationPlex.VideoFromAnimeGroup(session,grp,user.JMMUserID,allSeries);
}
}
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 void UpdateKodiAnimeGroup(ISession session, AnimeGroup grp, List<AnimeSeries> allSeries)
{
JMMUserRepository repUser = new JMMUserRepository();
AnimeGroup_UserRepository repUserGroups = new AnimeGroup_UserRepository();
foreach (JMMUser user in repUser.GetAll(session))
{
AnimeGroup_User userRec = repUserGroups.GetByUserAndGroupID(session, user.JMMUserID, grp.AnimeGroupID);
Dictionary<int, JMMContracts.KodiContracts.Video> cdic;
if (StatKodiGroupsCache.ContainsKey(user.JMMUserID))
cdic = StatKodiGroupsCache[user.JMMUserID];
else
{
cdic = new Dictionary<int, JMMContracts.KodiContracts.Video>();
StatKodiGroupsCache[user.JMMUserID] = cdic;
}
cdic[grp.AnimeGroupID] = KodiHelper.VideoFromAnimeGroup(session, grp, user.JMMUserID, allSeries);
}
}
public void RecreateAllGroups()
{
try
{
// pause queues
JMMService.CmdProcessorGeneral.Paused = true;
JMMService.CmdProcessorHasher.Paused = true;
JMMService.CmdProcessorImages.Paused = true;
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repGroupUser = new AnimeGroup_UserRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
// get all the old groups
List<AnimeGroup> oldGroups = repGroups.GetAll();
List<AnimeGroup_User> oldGroupUsers = repGroupUser.GetAll();
// create a new group, where we will place all the series temporarily
AnimeGroup tempGroup = new AnimeGroup();
tempGroup.GroupName = "AAA Migrating Groups AAA";
tempGroup.Description = "AAA Migrating Groups AAA";
tempGroup.SortName = "AAA Migrating Groups AAA";
tempGroup.DateTimeUpdated = DateTime.Now;
tempGroup.DateTimeCreated = DateTime.Now;
repGroups.Save(tempGroup);
// move all series to the new group
foreach (AnimeSeries ser in repSeries.GetAll())
{
ser.AnimeGroupID = tempGroup.AnimeGroupID;
repSeries.Save(ser, false);
}
// delete all the old groups
foreach (AnimeGroup grp in oldGroups)
repGroups.Delete(grp.AnimeGroupID);
// delete all the old group user records
foreach (AnimeGroup_User grpUser in oldGroupUsers)
repGroupUser.Delete(grpUser.AnimeGroupID);
// recreate groups
foreach (AnimeSeries ser in repSeries.GetAll())
{
bool createNewGroup = true;
if (ServerSettings.AutoGroupSeries)
{
List<AnimeGroup> grps = AnimeGroup.GetRelatedGroupsFromAnimeID(ser.AniDB_ID);
// only use if there is just one result
if (grps != null && grps.Count > 0 && !grps[0].GroupName.Equals("AAA Migrating Groups AAA"))
{
ser.AnimeGroupID = grps[0].AnimeGroupID;
createNewGroup = false;
}
}
if (createNewGroup)
{
AnimeGroup anGroup = new AnimeGroup();
anGroup.Populate(ser);
repGroups.Save(anGroup);
ser.AnimeGroupID = anGroup.AnimeGroupID;
}
repSeries.Save(ser, false);
}
// delete the temp group
if (tempGroup.GetAllSeries().Count == 0)
repGroups.Delete(tempGroup.AnimeGroupID);
// create group user records and update group stats
foreach (AnimeGroup grp in repGroups.GetAll())
grp.UpdateStatsFromTopLevel(true, true);
// un-pause queues
JMMService.CmdProcessorGeneral.Paused = false;
JMMService.CmdProcessorHasher.Paused = false;
JMMService.CmdProcessorImages.Paused = false;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
public Contract_AnimeGroup_SaveResponse SaveGroup(Contract_AnimeGroup_Save contract, int userID)
{
Contract_AnimeGroup_SaveResponse contractout = new Contract_AnimeGroup_SaveResponse();
contractout.ErrorMessage = "";
contractout.AnimeGroup = null;
try
{
AnimeGroupRepository repGroup = new AnimeGroupRepository();
AnimeGroup grp = null;
if (contract.AnimeGroupID.HasValue)
{
grp = repGroup.GetByID(contract.AnimeGroupID.Value);
if (grp == null)
{
contractout.ErrorMessage = "Could not find existing group with ID: " + contract.AnimeGroupID.Value.ToString();
return contractout;
}
}
else
{
grp = new AnimeGroup();
grp.Description = "";
grp.IsManuallyNamed = 0;
grp.DateTimeCreated = DateTime.Now;
grp.DateTimeUpdated = DateTime.Now;
grp.SortName = "";
grp.MissingEpisodeCount = 0;
grp.MissingEpisodeCountGroups = 0;
grp.OverrideDescription = 0;
}
if (string.IsNullOrEmpty(contract.GroupName))
{
contractout.ErrorMessage = "Must specify a group name";
return contractout;
}
grp.AnimeGroupParentID = contract.AnimeGroupParentID;
grp.Description = contract.Description;
grp.GroupName = contract.GroupName;
grp.IsManuallyNamed = contract.IsManuallyNamed;
grp.OverrideDescription = 0;
if (string.IsNullOrEmpty(contract.SortName))
grp.SortName = contract.GroupName;
else
grp.SortName = contract.SortName;
repGroup.Save(grp);
AnimeGroup_User userRecord = grp.GetUserRecord(userID);
if (userRecord == null) userRecord = new AnimeGroup_User(userID, grp.AnimeGroupID);
userRecord.IsFave = contract.IsFave;
AnimeGroup_UserRepository repUserRecords = new AnimeGroup_UserRepository();
repUserRecords.Save(userRecord);
Contract_AnimeGroup contractGrp = grp.ToContract(grp.GetUserRecord(userID));
contractout.AnimeGroup = contractGrp;
return contractout;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
contractout.ErrorMessage = ex.Message;
return contractout;
}
}
public AnimeGroup_User GetUserRecord(ISession session, int userID)
{
AnimeGroup_UserRepository repUser = new AnimeGroup_UserRepository();
return repUser.GetByUserAndGroupID(session, userID, this.AnimeGroupID);
}
/// <summary>
/// Update the stats for this group based on the child series
/// Assumes that all the AnimeSeries have had their stats updated already
/// </summary>
public void UpdateStats(bool watchedStats, bool missingEpsStats)
{
List<AnimeSeries> seriesList = GetAllSeries();
JMMUserRepository repUsers = new JMMUserRepository();
List<JMMUser> allUsers = repUsers.GetAll();
if (watchedStats)
{
foreach (JMMUser juser in allUsers)
{
AnimeGroup_User userRecord = GetUserRecord(juser.JMMUserID);
if (userRecord == null) userRecord = new AnimeGroup_User(juser.JMMUserID, this.AnimeGroupID);
// reset stats
userRecord.WatchedCount = 0;
userRecord.UnwatchedEpisodeCount = 0;
userRecord.PlayedCount = 0;
userRecord.StoppedCount = 0;
userRecord.WatchedEpisodeCount = 0;
userRecord.WatchedDate = null;
foreach (AnimeSeries ser in seriesList)
{
AnimeSeries_User serUserRecord = ser.GetUserRecord(juser.JMMUserID);
if (serUserRecord != null)
{
userRecord.WatchedCount += serUserRecord.WatchedCount;
userRecord.UnwatchedEpisodeCount += serUserRecord.UnwatchedEpisodeCount;
userRecord.PlayedCount += serUserRecord.PlayedCount;
userRecord.StoppedCount += serUserRecord.StoppedCount;
userRecord.WatchedEpisodeCount += serUserRecord.WatchedEpisodeCount;
if (serUserRecord.WatchedDate.HasValue)
{
if (userRecord.WatchedDate.HasValue)
{
if (serUserRecord.WatchedDate > userRecord.WatchedDate)
userRecord.WatchedDate = serUserRecord.WatchedDate;
}
else
userRecord.WatchedDate = serUserRecord.WatchedDate;
}
}
}
// now update the stats for the groups
logger.Trace("Updating stats for {0}", this.ToString());
AnimeGroup_UserRepository rep = new AnimeGroup_UserRepository();
rep.Save(userRecord);
}
}
if (missingEpsStats)
{
this.MissingEpisodeCount = 0;
this.MissingEpisodeCountGroups = 0;
foreach (AnimeSeries ser in seriesList)
{
this.MissingEpisodeCount += ser.MissingEpisodeCount;
this.MissingEpisodeCountGroups += ser.MissingEpisodeCountGroups;
}
AnimeGroupRepository repGrp = new AnimeGroupRepository();
repGrp.Save(this);
}
}
public void Delete(int id)
{
AnimeGroup cr = GetByID(id);
if (cr != null)
{
// delete user records
AnimeGroup_UserRepository repUsers = new AnimeGroup_UserRepository();
foreach (AnimeGroup_User grpUser in repUsers.GetByGroupID(id))
repUsers.Delete(grpUser.AnimeGroup_UserID);
}
int parentID = 0;
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
if (cr != null)
{
if (cr.AnimeGroupParentID.HasValue) parentID = cr.AnimeGroupParentID.Value;
session.Delete(cr);
transaction.Commit();
}
}
}
if (parentID > 0)
{
logger.Trace("Updating group stats by group from AnimeGroupRepository.Delete: {0}", parentID);
StatsCache.Instance.UpdateUsingGroup(parentID);
}
}
