public List <AnimeGroup> GetAllChildGroups(ISession session)
{
List <AnimeGroup> grpList = new List <AnimeGroup>();
AnimeGroup.GetAnimeGroupsRecursive(session, this.AnimeGroupID, ref grpList);
return(grpList);
}
public List <AnimeSeries> GetAllSeries(ISession session)
{
List <AnimeSeries> seriesList = new List <AnimeSeries>();
AnimeGroup.GetAnimeSeriesRecursive(session, this.AnimeGroupID, ref seriesList);
return(seriesList);
}
public void UpdateGroupFilter(HashSet <GroupFilterConditionType> types)
{
AnimeGroup grp = RepoFactory.AnimeGroup.GetByID(AnimeGroupID);
JMMUser usr = RepoFactory.JMMUser.GetByID(JMMUserID);
if (grp != null && usr != null)
{
grp.UpdateGroupFilters(types, usr);
}
}
public bool AllowedGroup(AnimeGroup grp)
{
if (Contract.HideCategories.Count == 0)
{
return(true);
}
if (grp.Contract == null)
{
return(false);
}
return(!Contract.HideCategories.FindInEnumerable(grp.Contract.Stat_AllTags));
}
public void UpdateGroupFilter(HashSet <GroupFilterConditionType> types)
{
AnimeGroupRepository repo = new AnimeGroupRepository();
JMMUserRepository repouser = new JMMUserRepository();
AnimeGroup grp = repo.GetByID(AnimeGroupID);
JMMUser usr = repouser.GetByID(JMMUserID);
if (grp != null && usr != null)
{
grp.UpdateGroupFilters(types, usr);
}
}
public void UpdatePlexKodiContracts(ISessionWrapper session = null)
{
AnimeGroup grp = RepoFactory.AnimeGroup.GetByID(AnimeGroupID);
if (grp == null)
{
return;
}
List <AnimeSeries> series = grp.GetAllSeries();
PlexContract = Helper.GenerateFromAnimeGroup(grp, JMMUserID, series, session);
}
public void UpdatePlexKodiContracts()
{
using (var session = JMMService.SessionFactory.OpenSession())
{
AnimeGroupRepository repo = new AnimeGroupRepository();
AnimeGroup grp = repo.GetByID(AnimeGroupID);
if (grp == null)
{
return;
}
List <AnimeSeries> series = grp.GetAllSeries(session);
PlexContract = Helper.GenerateFromAnimeGroup(session, grp, JMMUserID, series);
}
}
public void Save(AnimeGroup obj)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
logger.Trace("Updating group stats by group from AnimeGroupRepository.Save: {0}", obj.AnimeGroupID);
StatsCache.Instance.UpdateUsingGroup(obj.AnimeGroupID);
}
public void UpdatePlexKodiContracts()
{
using (var session = JMMService.SessionFactory.OpenSession())
{
ISessionWrapper sessionWrapper = session.Wrap();
AnimeGroup grp = RepoFactory.AnimeGroup.GetByID(AnimeGroupID);
if (grp == null)
{
return;
}
List <AnimeSeries> series = grp.GetAllSeries(sessionWrapper);
PlexContract = Helper.GenerateFromAnimeGroup(sessionWrapper, grp, JMMUserID, series);
}
}
public static void GetAnimeGroupsRecursive(ISession session, int animeGroupID, ref List <AnimeGroup> groupList)
{
AnimeGroupRepository rep = new AnimeGroupRepository();
AnimeGroup grp = rep.GetByID(session, animeGroupID);
if (grp == null)
{
return;
}
// get the child groups for this group
groupList.AddRange(grp.GetChildGroups(session));
foreach (AnimeGroup childGroup in grp.GetChildGroups(session))
{
GetAnimeGroupsRecursive(session, childGroup.AnimeGroupID, ref groupList);
}
}
public bool AllowedGroup(AnimeGroup grp, AnimeGroup_User userRec)
{
if (string.IsNullOrEmpty(HideCategories))
{
return(true);
}
string[] cats = HideCategories.ToLower().Split(',');
string[] animeCats = grp.ToContract(userRec).Stat_AllTags.ToLower().Split('|');
foreach (string cat in cats)
{
if (!string.IsNullOrEmpty(cat.Trim()) && animeCats.Contains(cat.Trim()))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Creates an <see cref="AnimeGroup"/> instance.
/// </summary>
/// <remarks>
/// This method only creates an <see cref="AnimeGroup"/> instance. It does NOT save it to the database.
/// </remarks>
/// <param name="session">The NHibernate session.</param>
/// <param name="mainSeries">The <see cref="AnimeSeries"/> whose name will represent the group (Optional. Pass <c>null</c> if not available).</param>
/// <param name="mainAnimeId">The ID of the anime whose name will represent the group if <paramref name="mainSeries"/> is <c>null</c>.</param>
/// <param name="now">The current date/time.</param>
/// <returns>The created <see cref="AnimeGroup"/>.</returns>
private AnimeGroup CreateAnimeGroup(ISessionWrapper session, AnimeSeries mainSeries, int mainAnimeId, DateTime now)
{
AnimeGroup animeGroup = new AnimeGroup();
string groupName = null;
if (mainSeries != null)
{
animeGroup.Populate(mainSeries, now);
groupName = mainSeries.GetSeriesName(session);
}
else // The anime chosen as the group's main anime doesn't actually have a series
{
AniDB_Anime mainAnime = _aniDbAnimeRepo.GetByAnimeID(mainAnimeId);
animeGroup.Populate(mainAnime, now);
groupName = mainAnime.GetFormattedTitle();
}
groupName = _truncateYearRegex.Replace(groupName, String.Empty); // If the title appears to end with a year suffix, then remove it
animeGroup.GroupName = groupName;
animeGroup.SortName = groupName;
return animeGroup;
}
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 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);
}
}
/// <summary>
/// Creates a new group that series will be put in during group re-calculation.
/// </summary>
/// <param name="session">The NHibernate session.</param>
/// <returns>The temporary <see cref="AnimeGroup"/>.</returns>
private AnimeGroup CreateTempAnimeGroup(ISessionWrapper session)
{
DateTime now = DateTime.Now;
var tempGroup = new AnimeGroup
{
GroupName = TempGroupName,
Description = TempGroupName,
SortName = TempGroupName,
DateTimeUpdated = now,
DateTimeCreated = now
};
// We won't use AnimeGroupRepository.Save because we don't need to perform all the extra stuff since this is for temporary use only
session.Insert(tempGroup);
return tempGroup;
}
public bool AllowedGroup(AnimeGroup grp, AnimeGroup_User userRec)
{
if (grp.AnimeGroupID == 266)
Console.Write("");
if (string.IsNullOrEmpty(HideCategories)) return true;
string[] cats = HideCategories.ToLower().Split(',');
string[] animeCats = grp.ToContract(userRec).Stat_AllCategories.ToLower().Split('|');
foreach (string cat in cats)
{
if (!string.IsNullOrEmpty(cat) && animeCats.Contains(cat))
{
return false;
}
}
return true;
}
public bool EvaluateGroupFilter(GroupFilter gf, AnimeGroup grp, JMMUser curUser, AnimeGroup_User userRec)
{
// sub groups don't count
if (grp.AnimeGroupParentID.HasValue) return false;
// make sure the user has not filtered this out
if (!curUser.AllowedGroup(grp, userRec)) return false;
// first check for anime groups which are included exluded every time
foreach (GroupFilterCondition gfc in gf.FilterConditions)
{
if (gfc.ConditionTypeEnum != GroupFilterConditionType.AnimeGroup) continue;
int groupID = 0;
int.TryParse(gfc.ConditionParameter, out groupID);
if (groupID == 0) break;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Equals)
if (groupID == grp.AnimeGroupID) return true;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotEquals)
if (groupID == grp.AnimeGroupID) return false;
}
NumberStyles style = NumberStyles.Number;
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-GB");
if (gf.BaseCondition == (int)GroupFilterBaseCondition.Exclude) return false;
Contract_AnimeGroup contractGroup = grp.ToContract(userRec);
// now check other conditions
foreach (GroupFilterCondition gfc in gf.FilterConditions)
{
switch (gfc.ConditionTypeEnum)
{
case GroupFilterConditionType.Favourite:
if (userRec == null) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && userRec.IsFave == 0) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && userRec.IsFave == 1) return false;
break;
case GroupFilterConditionType.MissingEpisodes:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && grp.HasMissingEpisodesAny == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && grp.HasMissingEpisodesAny == true) return false;
break;
case GroupFilterConditionType.MissingEpisodesCollecting:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && grp.HasMissingEpisodesGroups == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && grp.HasMissingEpisodesGroups == true) return false;
break;
case GroupFilterConditionType.HasWatchedEpisodes:
if (userRec == null) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && userRec.AnyFilesWatched == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && userRec.AnyFilesWatched == true) return false;
break;
case GroupFilterConditionType.HasUnwatchedEpisodes:
if (userRec == null) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && userRec.HasUnwatchedFiles == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && userRec.HasUnwatchedFiles == true) return false;
break;
case GroupFilterConditionType.AssignedTvDBInfo:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_HasTvDBLink == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_HasTvDBLink == true) return false;
break;
case GroupFilterConditionType.AssignedMALInfo:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_HasMALLink == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_HasMALLink == true) return false;
break;
case GroupFilterConditionType.AssignedMovieDBInfo:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_HasMovieDBLink == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_HasMovieDBLink == true) return false;
break;
case GroupFilterConditionType.AssignedTvDBOrMovieDBInfo:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_HasMovieDBOrTvDBLink == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_HasMovieDBOrTvDBLink == true) return false;
break;
case GroupFilterConditionType.CompletedSeries:
/*if (grp.IsComplete != grp.Stat_IsComplete)
{
Debug.Print("IsComplete DIFF {0}", grp.GroupName);
}*/
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_IsComplete == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_IsComplete == true) return false;
break;
case GroupFilterConditionType.FinishedAiring:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_HasFinishedAiring == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_IsCurrentlyAiring == false) return false;
break;
case GroupFilterConditionType.UserVoted:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_UserVotePermanent.HasValue == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_UserVotePermanent.HasValue == true) return false;
break;
case GroupFilterConditionType.UserVotedAny:
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Include && contractGroup.Stat_UserVoteOverall.HasValue == false) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.Exclude && contractGroup.Stat_UserVoteOverall.HasValue == true) return false;
break;
case GroupFilterConditionType.AirDate:
DateTime filterDate;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
int days = 0;
int.TryParse(gfc.ConditionParameter, out days);
filterDate = DateTime.Today.AddDays(0 - days);
}
else
filterDate = GetDateFromString(gfc.ConditionParameter);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan || gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
if (!contractGroup.Stat_AirDate_Min.HasValue || !contractGroup.Stat_AirDate_Max.HasValue) return false;
if (contractGroup.Stat_AirDate_Max.Value < filterDate) return false;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan)
{
if (!contractGroup.Stat_AirDate_Min.HasValue || !contractGroup.Stat_AirDate_Max.HasValue) return false;
if (contractGroup.Stat_AirDate_Min.Value > filterDate) return false;
}
break;
case GroupFilterConditionType.SeriesCreatedDate:
DateTime filterDateSeries;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
int days = 0;
int.TryParse(gfc.ConditionParameter, out days);
filterDateSeries = DateTime.Today.AddDays(0 - days);
}
else
filterDateSeries = GetDateFromString(gfc.ConditionParameter);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan || gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
if (!contractGroup.Stat_SeriesCreatedDate.HasValue) return false;
if (contractGroup.Stat_SeriesCreatedDate.Value < filterDateSeries) return false;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan)
{
if (!contractGroup.Stat_SeriesCreatedDate.HasValue) return false;
if (contractGroup.Stat_SeriesCreatedDate.Value > filterDateSeries) return false;
}
break;
case GroupFilterConditionType.EpisodeWatchedDate:
DateTime filterDateEpsiodeWatched;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
int days = 0;
int.TryParse(gfc.ConditionParameter, out days);
filterDateEpsiodeWatched = DateTime.Today.AddDays(0 - days);
}
else
filterDateEpsiodeWatched = GetDateFromString(gfc.ConditionParameter);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan || gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
if (userRec == null) return false;
if (!userRec.WatchedDate.HasValue) return false;
if (userRec.WatchedDate.Value < filterDateEpsiodeWatched) return false;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan)
{
if (userRec == null) return false;
if (!userRec.WatchedDate.HasValue) return false;
if (userRec.WatchedDate.Value > filterDateEpsiodeWatched) return false;
}
break;
case GroupFilterConditionType.EpisodeAddedDate:
DateTime filterDateEpisodeAdded;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
int days = 0;
int.TryParse(gfc.ConditionParameter, out days);
filterDateEpisodeAdded = DateTime.Today.AddDays(0 - days);
}
else
filterDateEpisodeAdded = GetDateFromString(gfc.ConditionParameter);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan || gfc.ConditionOperatorEnum == GroupFilterOperator.LastXDays)
{
if (!grp.EpisodeAddedDate.HasValue) return false;
if (grp.EpisodeAddedDate.Value < filterDateEpisodeAdded) return false;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan)
{
if (!grp.EpisodeAddedDate.HasValue) return false;
if (grp.EpisodeAddedDate.Value > filterDateEpisodeAdded) return false;
}
break;
case GroupFilterConditionType.EpisodeCount:
int epCount = -1;
int.TryParse(gfc.ConditionParameter, out epCount);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan && contractGroup.Stat_EpisodeCount < epCount) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan && contractGroup.Stat_EpisodeCount > epCount) return false;
break;
case GroupFilterConditionType.AniDBRating:
decimal dRating = -1;
decimal.TryParse(gfc.ConditionParameter, style, culture, out dRating);
decimal thisRating = contractGroup.Stat_AniDBRating / (decimal)100;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan && thisRating < dRating) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan && thisRating > dRating) return false;
break;
case GroupFilterConditionType.UserRating:
if (!contractGroup.Stat_UserVoteOverall.HasValue) return false;
decimal dUserRating = -1;
decimal.TryParse(gfc.ConditionParameter, style, culture, out dUserRating);
if (gfc.ConditionOperatorEnum == GroupFilterOperator.GreaterThan && contractGroup.Stat_UserVoteOverall.Value < dUserRating) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.LessThan && contractGroup.Stat_UserVoteOverall.Value > dUserRating) return false;
break;
case GroupFilterConditionType.Category:
string filterParm = gfc.ConditionParameter.Trim();
string[] cats = filterParm.Split(',');
bool foundCat = false;
int index = 0;
foreach (string cat in cats)
{
if (cat.Trim().Length == 0) continue;
if (cat.Trim() == ",") continue;
index = contractGroup.Stat_AllCategories.IndexOf(cat, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1)
{
foundCat = true;
break;
}
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.In)
if (!foundCat) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotIn)
if (foundCat) return false;
break;
case GroupFilterConditionType.AnimeType:
filterParm = gfc.ConditionParameter.Trim();
List<string> grpTypeList = grp.AnimeTypesList;
string[] atypes = filterParm.Split(',');
bool foundAnimeType = false;
index = 0;
foreach (string atype in atypes)
{
if (atype.Trim().Length == 0) continue;
if (atype.Trim() == ",") continue;
foreach (string thisAType in grpTypeList)
{
if (string.Equals(thisAType, atype, StringComparison.InvariantCultureIgnoreCase))
{
foundAnimeType = true;
break;
}
}
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.In)
if (!foundAnimeType) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotIn)
if (foundAnimeType) return false;
break;
case GroupFilterConditionType.VideoQuality:
filterParm = gfc.ConditionParameter.Trim();
string[] vidQuals = filterParm.Split(',');
bool foundVid = false;
bool foundVidAllEps = false;
index = 0;
foreach (string vidq in vidQuals)
{
if (vidq.Trim().Length == 0) continue;
if (vidq.Trim() == ",") continue;
index = contractGroup.Stat_AllVideoQuality.IndexOf(vidq, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1) foundVid = true;
index = contractGroup.Stat_AllVideoQuality_Episodes.IndexOf(vidq, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1) foundVidAllEps = true;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.In)
if (!foundVid) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotIn)
if (foundVid) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.InAllEpisodes)
if (!foundVidAllEps) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotInAllEpisodes)
if (foundVidAllEps) return false;
break;
case GroupFilterConditionType.AudioLanguage:
case GroupFilterConditionType.SubtitleLanguage:
filterParm = gfc.ConditionParameter.Trim();
string[] languages = filterParm.Split(',');
bool foundLan = false;
index = 0;
foreach (string lanName in languages)
{
if (lanName.Trim().Length == 0) continue;
if (lanName.Trim() == ",") continue;
if (gfc.ConditionTypeEnum == GroupFilterConditionType.AudioLanguage)
index = contractGroup.Stat_AudioLanguages.IndexOf(lanName, 0, StringComparison.InvariantCultureIgnoreCase);
if (gfc.ConditionTypeEnum == GroupFilterConditionType.SubtitleLanguage)
index = contractGroup.Stat_SubtitleLanguages.IndexOf(lanName, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1) foundLan = true;
}
if (gfc.ConditionOperatorEnum == GroupFilterOperator.In)
if (!foundLan) return false;
if (gfc.ConditionOperatorEnum == GroupFilterOperator.NotIn)
if (foundLan) return false;
break;
}
}
return true;
}
private static void GetAnimeSeriesRecursive(AnimeGroup grp, ref List<AnimeSeries> seriesList, List<AnimeSeries> allSeries, Dictionary<int, AnimeGroup> allGroupsDict)
{
// get the series for this group
List<AnimeSeries> thisSeries = new List<AnimeSeries>();
foreach (AnimeSeries ser in allSeries)
if (ser.AnimeGroupID == grp.AnimeGroupID) seriesList.Add(ser);
foreach (KeyValuePair<int, AnimeGroup> kvp in allGroupsDict)
{
if (kvp.Value.AnimeGroupParentID.HasValue && kvp.Value.AnimeGroupParentID.Value == grp.AnimeGroupID)
{
GetAnimeSeriesRecursive(kvp.Value, ref seriesList, allSeries, allGroupsDict);
}
}
/*foreach (AnimeGroup childGroup in grp.ChildGroups)
{
GetAnimeSeriesRecursive(childGroup, ref seriesList, allSeries, allGroupsDict);
}*/
}
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 AnimeSeries CreateAnimeSeriesAndGroup(ISession session)
{
// create a new AnimeSeries record
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeSeries ser = new AnimeSeries();
ser.Populate(this);
JMMUserRepository repUsers = new JMMUserRepository();
List<JMMUser> allUsers = repUsers.GetAll(session);
// create the AnimeGroup record
// check if there are any existing groups we could add this series to
bool createNewGroup = true;
if (ServerSettings.AutoGroupSeries)
{
List<AnimeGroup> grps = AnimeGroup.GetRelatedGroupsFromAnimeID(session, ser.AniDB_ID);
// only use if there is just one result
if (grps != null && grps.Count > 0)
{
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);
// check for TvDB associations
CommandRequest_TvDBSearchAnime cmd = new CommandRequest_TvDBSearchAnime(this.AnimeID, false);
cmd.Save();
// check for Trakt associations
if (ServerSettings.Trakt_IsEnabled && !string.IsNullOrEmpty(ServerSettings.Trakt_AuthToken))
{
CommandRequest_TraktSearchAnime cmd2 = new CommandRequest_TraktSearchAnime(this.AnimeID, false);
cmd2.Save();
}
return ser;
}
/// <summary>
/// Creates a single <see cref="AnimeGroup"/> for each <see cref="AnimeSeries"/> in <paramref name="seriesList"/>.
/// </summary>
/// <remarks>
/// This method assumes that there are no active transactions on the specified <paramref name="session"/>.
/// </remarks>
/// <param name="session">The NHibernate session.</param>
/// <param name="seriesList">The list of <see cref="AnimeSeries"/> to create groups for.</param>
/// <returns>A sequence of the created <see cref="AnimeGroup"/>s.</returns>
private IEnumerable<AnimeGroup> CreateGroupPerSeries(ISessionWrapper session, IReadOnlyList<AnimeSeries> seriesList)
{
_log.Info("Generating AnimeGroups for {0} AnimeSeries", seriesList.Count);
DateTime now = DateTime.Now;
var newGroupsToSeries = new Tuple<AnimeGroup, AnimeSeries>[seriesList.Count];
// Create one group per series
for (int grp = 0; grp < seriesList.Count; grp++)
{
AnimeGroup group = new AnimeGroup();
AnimeSeries series = seriesList[grp];
group.Populate(series, now);
newGroupsToSeries[grp] = new Tuple<AnimeGroup, AnimeSeries>(group, series);
}
using (ITransaction trans = session.BeginTransaction())
{
_animeGroupRepo.InsertBatch(session, newGroupsToSeries.Select(gts => gts.Item1).AsReadOnlyCollection());
trans.Commit();
}
// Anime groups should have IDs now they've been inserted. Now assign the group ID's to their respective series
// (The caller of this method will be responsible for saving the AnimeSeries)
foreach (Tuple<AnimeGroup, AnimeSeries> groupAndSeries in newGroupsToSeries)
{
groupAndSeries.Item2.AnimeGroupID = groupAndSeries.Item1.AnimeGroupID;
}
_log.Info("Generated {0} AnimeGroups", newGroupsToSeries.Length);
return newGroupsToSeries.Select(gts => gts.Item1);
}
/// <summary>
/// Gets or creates an <see cref="AnimeGroup"/> for the specified series.
/// </summary>
/// <param name="session">The NHibernate session.</param>
/// <param name="series">The series for which the group is to be created/retrieved (Must be initialised first).</param>
/// <returns>The <see cref="AnimeGroup"/> to use for the specified series.</returns>
/// <exception cref="ArgumentNullException"><paramref name="session"/> or <paramref name="series"/> is <c>null</c>.</exception>
public AnimeGroup GetOrCreateSingleGroupForSeries(ISessionWrapper session, AnimeSeries series)
{
if (session == null)
throw new ArgumentNullException(nameof(session));
if (series == null)
throw new ArgumentNullException(nameof(series));
AnimeGroup animeGroup = null;
if (_autoGroupSeries)
{
var grpCalculator = AutoAnimeGroupCalculator.CreateFromServerSettings(session);
IReadOnlyList<int> grpAnimeIds = grpCalculator.GetIdsOfAnimeInSameGroup(series.AniDB_ID);
// Try to find an existing AnimeGroup to add the series to
// We basically pick the first group that any of the related series belongs to already
animeGroup = grpAnimeIds.Select(id => RepoFactory.AnimeSeries.GetByAnimeID(id))
.Where(s => s != null)
.Select(s => RepoFactory.AnimeGroup.GetByID(s.AnimeGroupID))
.FirstOrDefault();
if (animeGroup == null)
{
// No existing group was found, so create a new one
int mainAnimeId = grpCalculator.GetGroupAnimeId(series.AniDB_ID);
AnimeSeries mainSeries = _animeSeriesRepo.GetByAnimeID(mainAnimeId);
animeGroup = CreateAnimeGroup(session, mainSeries, mainAnimeId, DateTime.Now);
RepoFactory.AnimeGroup.Save(animeGroup, true, true);
}
}
else // We're not auto grouping (e.g. we're doing group per series)
{
animeGroup = new AnimeGroup();
animeGroup.Populate(series, DateTime.Now);
RepoFactory.AnimeGroup.Save(animeGroup, true, true);
}
return animeGroup;
}
public static List <AnimeGroup> GetRelatedGroupsFromAnimeID(ISession session, int animeid)
{
// TODO we need to recusrive list at all relations and not just the first one
AniDB_AnimeRepository repAniAnime = new AniDB_AnimeRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List <AnimeGroup> grps = new List <AnimeGroup>();
AniDB_Anime anime = repAniAnime.GetByAnimeID(session, animeid);
if (anime == null)
{
return(grps);
}
// first check for groups which are directly related
List <AniDB_Anime_Relation> relations = anime.GetRelatedAnime(session);
foreach (AniDB_Anime_Relation rel in relations)
{
string relationtype = rel.RelationType.ToLower();
if ((relationtype == "same setting") || (relationtype == "alternative setting") ||
(relationtype == "character") || (relationtype == "other"))
{
//Filter these relations these will fix messes, like Gundam , Clamp, etc.
continue;
}
// we actually need to get the series, because it might have been added to another group already
AnimeSeries ser = repSeries.GetByAnimeID(session, rel.RelatedAnimeID);
if (ser != null)
{
AnimeGroup grp = repGroups.GetByID(session, ser.AnimeGroupID);
if (grp != null)
{
grps.Add(grp);
}
}
}
if (grps.Count > 0)
{
return(grps);
}
// if nothing found check by all related anime
List <AniDB_Anime> relatedAnime = anime.GetAllRelatedAnime(session);
foreach (AniDB_Anime rel in relatedAnime)
{
// we actually need to get the series, because it might have been added to another group already
AnimeSeries ser = repSeries.GetByAnimeID(session, rel.AnimeID);
if (ser != null)
{
AnimeGroup grp = repGroups.GetByID(session, ser.AnimeGroupID);
if (grp != null)
{
grps.Add(grp);
}
}
}
return(grps);
}
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);
}
}
