public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
string firstTitle = firstEntry.Title;
string secondTitle = secondEntry.Title;
if (IsAnyMobileFighterGGundam(firstTitle, secondTitle))
{
return(false);
}
if (IsAnyGNoReconguista(firstTitle, secondTitle))
{
if (IsBothGNoReconguista(firstTitle, secondTitle))
{
return(true);
}
return(false);
}
if (IsAnyIronBloodedOrphans(firstTitle, secondTitle))
{
if (IsBothIronBloodedOrphans(firstTitle, secondTitle))
{
return(true);
}
return(false);
}
if (IsAnyKimiGaNozomuEien(firstTitle, secondTitle))
{
return(false);
}
return(firstTitle.ContainsAnySharedWord(secondTitle));
}
public RelationBetweenEntries(IEntryInstance source, IEntryInstance related, RelationType targetForSourceType,
RelationType sourceForTargetType = RelationType.None)
{
SourceEntry = source;
TargetEntry = related;
TargetForSourceType = targetForSourceType;
SourceForTargetType = sourceForTargetType;
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
var firstIsParentStoryForSecond = secondEntry.Related.AllRelatedPositions
.Any(r => r.MalId == firstEntry.Id &&
(r.RelationType.In(RelationType.ParentStory, RelationType.FullStory, RelationType.SideStory)));
return(firstIsParentStoryForSecond);
}
private static IEntryInstance ReplaceMainEntryIfOtherNotNull(IEntryInstance mainEntry, IEntryInstance otherEntry,
List <IEntryInstance> rejectedEntries)
{
if (otherEntry == null)
{
return(mainEntry);
}
rejectedEntries.Add(mainEntry);
return(otherEntry);
}
private bool HasMultipleParentStories(IEntryInstance entry)
{
if (entry.Related?.ParentStories?.Count > 1)
{
var firstTitle = entry.Related.ParentStories.First().Name;
var secondTitle = entry.Related.ParentStories.Last().Name;
var areRelated = firstTitle.ContainsAnySharedWord(secondTitle);
return(!areRelated);
}
return(false);
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
string firstTitle = firstEntry.Title;
string secondTitle = secondEntry.Title;
if (AnyTitleContainsAnyKeyword(firstTitle, secondTitle))
{
return(true);
}
return(false);
}
private static string GetMainTitle(ICollection <IEntryInstance> entries, IEntryInstance mainEntry)
{
var importantEntries = entries
.Where(e => e.Type.NotIn("Music", "ONA", "One-shot"))
.ToArray();
if (CollectionUtils.IsCollectionNullOrEmpty(importantEntries))
{
return(new MainTitleFinder().GetMainTitle(entries, mainEntry));
}
return(new MainTitleFinder().GetMainTitle(importantEntries, mainEntry));
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
if (firstEntry.Title.ContainsAnySharedWord(secondEntry.Title))
{
return(true);
}
if (NonImportantTypes.Contains(secondEntry.Type))
{
return(true);
}
return(false);
}
private bool IsCollaboration(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
if (secondEntry.Related.AllRelatedPositions.Count > 1 &&
CollaborationRegex.IsMatch(secondEntry.Title))
{
var match = CollaborationRegex.Match(secondEntry.Title);
var collabFirstTitle = match.Groups["firstPart"].Value;
var collabSecondTitle = match.Groups["secondPart"].Value;
if (firstEntry.Title.Equals(collabFirstTitle) || firstEntry.Title.Equals(collabSecondTitle))
{
return(true);
}
}
return(false);
}
private bool BothEntiresContainEveryWord(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
string firstTitle = firstEntry.Title, secondTitle = secondEntry.Title;
if (AreBothEntriesAreSubtitles(firstEntry, secondEntry))
{
firstTitle = GetMainTitlePart(firstTitle);
secondTitle = GetMainTitlePart(secondTitle);
}
if (!firstTitle.ContainsEverySharedWord(secondTitle))
{
return(false);
}
return(true);
}
private RelationBetweenEntries CreateRelation(IEntryInstance entry, IEntryInstance relatedEntry, RelationType relationType)
{
if (relationType != RelationType.ParentStory)
{
return(new RelationBetweenEntries(entry, relatedEntry, relationType));
}
var entryAsRelatedSubItem = relatedEntry.Related.AllRelatedPositions.FirstOrDefault(e => e.MalId == entry.Id);
if (entryAsRelatedSubItem == null)
{
return(new RelationBetweenEntries(entry, relatedEntry, relationType));
}
var targetToSourceRelation = entryAsRelatedSubItem.RelationType;
var relation = new RelationBetweenEntries(entry, relatedEntry, relationType, targetToSourceRelation);
return(relation);
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
if (!secondEntry.Related.AllRelatedPositions.Any(r => r.MalId == firstEntry.Id))
{
return(false);
}
if (NonImportantOthers.Any(nio => secondEntry.Title.Contains(nio)))
{
return(true);
}
if (IsCollaboration(firstEntry, secondEntry))
{
return(false);
}
if (secondEntry.Description.Contains(firstEntry.Title) && firstEntry.Title.ContainsAnySharedWord(secondEntry.Title))
{
return(true);
}
return(BothEntiresContainEveryWord(firstEntry, secondEntry));
}
private ICollection <RelationBetweenEntries> GetRelations(IEntryInstance entry, IEntryProvider entryProvider)
{
var allRelatedToEntry = entry.Related.AllRelatedPositions;
if (IsCollectionEmpty(allRelatedToEntry))
{
return(null);
}
var relations = new List <RelationBetweenEntries>();
var filteredEntries = allRelatedToEntry.Where(r => CanEntryBeAddedToSeries(r.MalId) && !IsIgnored(r.MalId, entryProvider));
foreach (var subItem in filteredEntries)
{
var relatedEntry = entryProvider.Get(subItem.MalId);
if (relatedEntry != null && !HasMultipleParentStories(relatedEntry))
{
var relation = CreateRelation(entry, relatedEntry, subItem.RelationType);
relations.Add(relation);
}
}
return(relations);
}
private static IEntryInstance FindMainEntry(ICollection <IEntryInstance> series)
{
var sortedEntries = series.Where(s => s.TimePeriod.From != null).OrderBy(a => a.Id).ToList();
IEntryInstance mainEntry = sortedEntries.First(), otherEntry = null;
var rejectedEntries = new List <IEntryInstance>();
for (int i = 0; i < sortedEntries.Count; ++i)
{
if (IsSecondaryTitle(mainEntry))
{
otherEntry = sortedEntries.Where(a => !IsSecondaryTitle(a) && !rejectedEntries.Contains(a)).FirstOrDefault();
mainEntry = ReplaceMainEntryIfOtherNotNull(mainEntry, otherEntry, rejectedEntries);
}
if (IsTooShortForMainSeries(mainEntry))
{
otherEntry = sortedEntries.Where(a => !IsTooShortForMainSeries(a) && !rejectedEntries.Contains(a)).FirstOrDefault();
mainEntry = ReplaceMainEntryIfOtherNotNull(mainEntry, otherEntry, rejectedEntries);
continue;
}
break;
}
return(mainEntry);
}
private bool BothTitlesAreMameshiba(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
return(IsTitleMameshiba(firstEntry) && IsTitleMameshiba(secondEntry));
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
var bothAreMameshiba = BothTitlesAreMameshiba(firstEntry, secondEntry);
return(bothAreMameshiba);
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
return(firstEntry.Title.ContainsAnySharedWord(secondEntry.Title));
}
private void AddEntryToCheckTheRelations(IEntryInstance entry)
{
entriesToCheckTheRelations.Push(entry);
}
public string GetMainTitle(ICollection <IEntryInstance> entries, IEntryInstance mainTitle)
{
return(GetMainTitle(entries.Select(e => e.Title).ToArray(), mainTitle.Title));
}
/// <summary>
/// Constructor for one entry, indicates an entry without a relation
/// </summary>
public RelationBetweenEntries(IEntryInstance entry)
{
SourceEntry = entry;
TargetEntry = null;
TargetForSourceType = SourceForTargetType = RelationType.None;
}
private bool AreBothEntriesAreSubtitles(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
return(SubtitleRegex.IsMatch(firstEntry.Title) && SubtitleRegex.IsMatch(secondEntry.Title));
}
private static bool IsSecondaryTitle(IEntryInstance entry)
{
return(SecondaryTitleKeywords.Any(k => entry.Title.Contains(k)) ||
(SecondaryTypeKeywords.Any(k => entry.Type.Contains(k) && entry.Episodes < 7)) ||
IsMovieExplicitly(entry));
}
private static bool IsMovieExplicitly(IEntryInstance entry)
{
return(entry.Title.Contains("Movie") && entry.Type.Contains("Movie"));
}
private bool IsTitleMameshiba(IEntryInstance entry)
{
return(entry.Title.ContainsCaseInsensitive(MameshibaKeyword));
}
public bool AreRelated(IEntryInstance firstEntry, IEntryInstance secondEntry)
{
return(true);
}
private static bool IsTooShortForMainSeries(IEntryInstance entry)
{
return(Regex.IsMatch(entry.Duration, "^[0-4] min"));
}
