public AniDB_File GetByFileID(int fileID)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
AniDB_File cr = session
.CreateCriteria(typeof(AniDB_File))
.Add(Restrictions.Eq("FileID", fileID))
.UniqueResult <AniDB_File>();
return(cr);
}
}
private static int CompareSourceTo(AniDB_File newFile, AniDB_File oldFile)
{
if (string.IsNullOrEmpty(newFile.File_Source) || string.IsNullOrEmpty(oldFile.File_Source))
{
return(0);
}
int newIndex = Array.IndexOf(Settings._sources, newFile.File_Source);
int oldIndex = Array.IndexOf(Settings._sources, oldFile.File_Source);
return(newIndex.CompareTo(oldIndex));
}
public void Save(AniDB_File obj)
{
using (var session = WebCache.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
public AniDB_File GetByHashAndFileSize(string hash, long fsize)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
AniDB_File cr = session
.CreateCriteria(typeof(AniDB_File))
.Add(Restrictions.Eq("Hash", hash))
.Add(Restrictions.Eq("FileSize", fsize))
.UniqueResult <AniDB_File>();
return(cr);
}
}
public static void Init()
{
JMMUser.Populate();
CloudAccount.Populate();
ImportFolder.Populate();
AniDB_Anime.Populate();
AniDB_Episode.Populate();
AniDB_File.Populate();
AniDB_Anime_Title.Populate();
AniDB_Anime_Tag.Populate();
AniDB_Tag.Populate();
CustomTag.Populate();
CrossRef_CustomTag.Populate();
CrossRef_File_Episode.Populate();
VideoLocalPlace.Populate();
VideoLocal.Populate();
VideoLocalUser.Populate();
GroupFilter.Populate();
AnimeEpisode.Populate();
AnimeEpisode_User.Populate();
AnimeSeries.Populate();
AnimeSeries_User.Populate();
AnimeGroup.Populate();
AnimeGroup_User.Populate();
// Update Contracts if necessary
JMMUser.RegenerateDb();
CloudAccount.RegenerateDb();
ImportFolder.RegenerateDb();
AniDB_Anime.RegenerateDb();
AniDB_Episode.RegenerateDb();
AniDB_File.RegenerateDb();
AniDB_Anime_Title.RegenerateDb();
AniDB_Anime_Tag.RegenerateDb();
AniDB_Tag.RegenerateDb();
CustomTag.RegenerateDb();
CrossRef_CustomTag.RegenerateDb();
CrossRef_File_Episode.RegenerateDb();
VideoLocalPlace.RegenerateDb();
VideoLocal.RegenerateDb();
VideoLocalUser.RegenerateDb();
AnimeEpisode.RegenerateDb();
AnimeEpisode_User.RegenerateDb();
AnimeSeries.RegenerateDb();
AnimeSeries_User.RegenerateDb();
AnimeGroup.RegenerateDb();
AnimeGroup_User.RegenerateDb();
GroupFilter.RegenerateDb();
GroupFilter.PostProcess();
CleanUpMemory();
}
/*
* public static WebCache_CrossRef_AniDB_Other_Request ToRequest(this CrossRef_AniDB_Other c)
* {
* return new WebCache_CrossRef_AniDB_Other_Request
* {
* CrossRef_AniDB_OtherID = c.CrossRef_AniDB_OtherID,
* AnimeID = c.AnimeID,
* CrossRefID = c.CrossRefID,
* CrossRefSource = c.CrossRefSource,
* CrossRefType = c.CrossRefType,
* };
* }
*/
public static WebCache_FileHash ToHashRequest(this AniDB_File anifile)
{
WebCache_FileHash r = new WebCache_FileHash
{
ED2K = anifile.Hash,
CRC32 = anifile.CRC,
MD5 = anifile.MD5,
SHA1 = anifile.SHA1,
FileSize = anifile.FileSize
};
return(r);
}
public static void Send_AniDB_File(AniDB_File data)
{
if (!ServerSettings.WebCache_AniDB_File_Send)
{
return;
}
string uri = string.Format("http://{0}/AddAniDB_File.aspx", ServerSettings.WebCache_Address);
AniDB_FileRequest req = new AniDB_FileRequest(data);
string xml = req.ToXML();
SendData(uri, xml);
}
public static Azure_FileHash_Request ToHashRequest(this AniDB_File anifile)
{
Azure_FileHash_Request r = new Azure_FileHash_Request
{
ED2K = anifile.Hash,
CRC32 = anifile.CRC,
MD5 = anifile.MD5,
SHA1 = anifile.SHA1,
FileSize = anifile.FileSize,
Username = Constants.AnonWebCacheUsername,
AuthGUID = string.Empty
};
return(r);
}
private static int CompareChapterTo(SVR_VideoLocal newFile, AniDB_File newAniFile, SVR_VideoLocal oldFile, AniDB_File oldAniFile)
{
if ((newAniFile?.IsChaptered == 1 || newFile.Media.Chaptered) &&
!(oldAniFile?.IsChaptered == 1 || oldFile.Media.Chaptered))
{
return(-1);
}
if (!(newAniFile?.IsChaptered == 1 || newFile.Media.Chaptered) &&
(oldAniFile?.IsChaptered == 1 || oldFile.Media.Chaptered))
{
return(1);
}
return((oldAniFile?.IsChaptered == 1 || oldFile.Media.Chaptered).CompareTo(
newAniFile?.IsChaptered == 1 || newFile.Media.Chaptered));
}
public void Delete(int id)
{
using (var session = WebCache.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
AniDB_File cr = GetByID(id);
if (cr != null)
{
session.Delete(cr);
transaction.Commit();
}
}
}
}
private static bool CheckSubGroup(AniDB_File aniFile)
{
FileQualityFilterOperationType operationType = Settings.RequiredSubGroupOperator;
switch (operationType)
{
case FileQualityFilterOperationType.IN:
return(Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) ||
Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
case FileQualityFilterOperationType.NOTIN:
return(!Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) &&
!Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
}
return(true);
}
private static int CompareSourceTo(AniDB_File newFile, AniDB_File oldFile)
{
if (string.IsNullOrEmpty(newFile.File_Source) || string.IsNullOrEmpty(oldFile.File_Source))
{
return(0);
}
if (newFile.File_Source.Equals("unknown", StringComparison.InvariantCultureIgnoreCase) ||
oldFile.File_Source.Equals("unknown", StringComparison.InvariantCultureIgnoreCase))
{
return(0);
}
int newIndex = Array.IndexOf(Settings._sources, newFile.File_Source.ToLowerInvariant());
int oldIndex = Array.IndexOf(Settings._sources, oldFile.File_Source.ToLowerInvariant());
return(newIndex.CompareTo(oldIndex));
}
private static int CompareChapterTo(SVR_VideoLocal newFile, AniDB_File newAniFile, SVR_VideoLocal oldFile,
AniDB_File oldAniFile)
{
if ((newAniFile?.IsChaptered == 1 || (newFile?.Media?.MenuStreams.Any() ?? false)) &&
!(oldAniFile?.IsChaptered == 1 || (oldFile?.Media?.MenuStreams.Any() ?? false)))
{
return(-1);
}
if (!(newAniFile?.IsChaptered == 1 || (newFile?.Media?.MenuStreams.Any() ?? false)) &&
(oldAniFile?.IsChaptered == 1 || (oldFile?.Media?.MenuStreams.Any() ?? false)))
{
return(1);
}
return((oldAniFile?.IsChaptered == 1 || (oldFile?.Media?.MenuStreams.Any() ?? false)).CompareTo(
newAniFile?.IsChaptered == 1 || (newFile?.Media?.MenuStreams.Any() ?? false)));
}
private static int CompareSubGroupTo(AniDB_File newFile, AniDB_File oldFile)
{
if (!Settings._subgroups.Contains(newFile.Anime_GroupName.ToLowerInvariant()))
{
return(0);
}
if (!Settings._subgroups.Contains(oldFile.Anime_GroupName.ToLowerInvariant()))
{
return(0);
}
// The above ensures that _subgroups contains both, so no need to check for -1 in this case
int newIndex = Array.IndexOf(Settings._subgroups, newFile.Anime_GroupName.ToLowerInvariant());
int oldIndex = Array.IndexOf(Settings._subgroups, oldFile.Anime_GroupName.ToLowerInvariant());
return(newIndex.CompareTo(oldIndex));
}
public FileHashInput(AniDB_File anifile)
{
ED2K = anifile.Hash;
CRC32 = anifile.CRC;
MD5 = anifile.MD5;
SHA1 = anifile.SHA1;
FileSize = anifile.FileSize;
this.Username = ServerSettings.AniDB_Username;
if (ServerSettings.WebCache_Anonymous)
{
this.Username = Constants.AnonWebCacheUsername;
}
this.AuthGUID = string.Empty;
}
protected void Page_Load(object sender, EventArgs e)
{
Response.ContentType = "text/xml";
try
{
Response.Write(Constants.ERROR_XML);
return;
string sfsize = Utils.GetParam("fsize");
long fsize = 0;
long.TryParse(sfsize, out fsize);
if (fsize <= 0)
{
Response.Write(Constants.ERROR_XML);
return;
}
string hash = Utils.GetParam("hash");
if (hash.Trim().Length == 0)
{
Response.Write(Constants.ERROR_XML);
return;
}
AniDB_FileRepository rep = new AniDB_FileRepository();
AniDB_File anifile = rep.GetByHashAndFileSize(hash, fsize);
if (anifile == null)
{
Response.Write(Constants.ERROR_XML);
return;
}
AniDB_FileRequest data = new AniDB_FileRequest(anifile);
string ret = Utils.ConvertToXML(data, typeof(AniDB_FileRequest));
Response.Write(ret);
}
catch (Exception ex)
{
Response.Write(ex.ToString());
return;
}
}
private static int CompareVideoCodecTo(SVR_VideoLocal newLocal, AniDB_File newFile, SVR_VideoLocal oldLocal, AniDB_File oldFile)
{
string[] newCodecs = newFile.File_VideoCodec.ToLowerInvariant().Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries);
string[] oldCodecs = oldFile.File_VideoCodec.ToLowerInvariant().Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries);
// compare side by side, average codec quality would be vague and annoying, defer to number of audio tracks
if (newCodecs.Length != oldCodecs.Length)
{
return(0);
}
for (int i = 0; i < Math.Min(newCodecs.Length, oldCodecs.Length); i++)
{
string newCodec = newCodecs[i];
string oldCodec = oldCodecs[i];
int newIndex = Array.IndexOf(Settings._videocodecs, newCodec);
int oldIndex = Array.IndexOf(Settings._videocodecs, oldCodec);
if (newIndex < 0 || oldIndex < 0)
{
continue;
}
int result = newIndex.CompareTo(oldIndex);
if (result != 0)
{
return(result);
}
if (string.IsNullOrEmpty(newLocal.VideoBitDepth) ||
string.IsNullOrEmpty(oldLocal.VideoBitDepth))
{
continue;
}
if ((newLocal.VideoBitDepth.Equals("8") || newLocal.VideoBitDepth.Equals("10")) &&
(oldLocal.VideoBitDepth.Equals("8") || oldLocal.VideoBitDepth.Equals("10")))
{
if (newLocal.VideoBitDepth.Equals("8") && oldLocal.VideoBitDepth.Equals("10"))
{
return(Settings.Prefer8BitVideo ? -1 : 1);
}
if (newLocal.VideoBitDepth.Equals("10") && oldLocal.VideoBitDepth.Equals("8"))
{
return(Settings.Prefer8BitVideo ? 1 : -1);
}
}
}
return(0);
}
public void Save(AniDB_File obj, bool updateStats)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
if (updateStats)
{
logger.Trace("Updating group stats by file from AniDB_FileRepository.Save: {0}", obj.Hash);
AniDB_Anime.UpdateStatsByAnimeID(obj.AnimeID);
}
}
private static bool CheckSource(AniDB_File aniFile)
{
if (string.IsNullOrEmpty(aniFile.File_Source))
{
return(false);
}
FileQualityFilterOperationType operationType = Settings.RequiredSourceOperator;
switch (operationType)
{
case FileQualityFilterOperationType.IN:
return(Settings._requiredsources.Item1.Contains(aniFile.File_Source.ToLowerInvariant()));
case FileQualityFilterOperationType.NOTIN:
return(!Settings._requiredsources.Item1.Contains(aniFile.File_Source.ToLowerInvariant()));
}
return(true);
}
public static bool IsNullOrUnknown(AniDB_File file)
{
if (file == null)
{
return(true);
}
if (string.IsNullOrWhiteSpace(file.File_Source))
{
return(true);
}
if (string.IsNullOrWhiteSpace(file.Anime_GroupName))
{
return(true);
}
if (string.IsNullOrWhiteSpace(file.Anime_GroupNameShort))
{
return(true);
}
if (file.Anime_GroupName.EqualsInvariantIgnoreCase("unknown"))
{
return(true);
}
if (file.Anime_GroupNameShort.EqualsInvariantIgnoreCase("unknown"))
{
return(true);
}
if (file.Anime_GroupName.EqualsInvariantIgnoreCase("raw"))
{
return(true);
}
if (file.Anime_GroupNameShort.EqualsInvariantIgnoreCase("raw"))
{
return(true);
}
if (file.File_Source.EqualsInvariantIgnoreCase("unknown"))
{
return(true);
}
if (file.File_Source.EqualsInvariantIgnoreCase("raw"))
{
return(true);
}
return(false);
}
protected void Page_Load(object sender, EventArgs e)
{
Response.ContentType = "text/xml";
try
{
Response.Write(Constants.ERROR_XML);
return;
AniDB_FileRepository rep = new AniDB_FileRepository();
StreamReader reader = new StreamReader(this.Request.InputStream);
String xmlData = reader.ReadToEnd();
XmlSerializer serializer = new XmlSerializer(typeof(AniDB_FileRequest));
XmlDocument docSearchResult = new XmlDocument();
docSearchResult.LoadXml(xmlData);
XmlNodeReader xmlreader = new XmlNodeReader(docSearchResult.DocumentElement);
object obj = serializer.Deserialize(xmlreader);
AniDB_FileRequest result = (AniDB_FileRequest)obj;
if (result == null)
{
Response.Write(Constants.ERROR_XML);
return;
}
AniDB_File anifile = rep.GetByFileID(result.FileID);
if (anifile == null)
{
anifile = new AniDB_File();
}
anifile.Populate(result);
rep.Save(anifile);
}
catch (Exception ex)
{
Response.Write(Constants.ERROR_XML);
}
}
private static int CompareVersionTo(SVR_VideoLocal newFile, SVR_VideoLocal oldFile)
{
AniDB_File newani = newFile.GetAniDBFile();
AniDB_File oldani = oldFile.GetAniDBFile();
if (!newani.Anime_GroupName.Equals(oldani.Anime_GroupName))
{
return(0);
}
if (!newani.File_VideoResolution.Equals(oldani.File_VideoResolution))
{
return(0);
}
if (!newFile.VideoBitDepth.Equals(oldFile.VideoBitDepth))
{
return(0);
}
return(oldani.FileVersion.CompareTo(newani.FileVersion));
}
private static int CompareSourceTo(AniDB_File newFile, AniDB_File oldFile)
{
var newSource = newFile.File_Source.ToLowerInvariant();
if (FileQualityPreferences.SimplifiedSources.ContainsKey(newSource))
{
newSource = FileQualityPreferences.SimplifiedSources[newSource];
}
var oldSource = oldFile.File_Source.ToLowerInvariant();
if (FileQualityPreferences.SimplifiedSources.ContainsKey(oldSource))
{
oldSource = FileQualityPreferences.SimplifiedSources[oldSource];
}
int newIndex = Array.IndexOf(Settings._sources, newSource);
int oldIndex = Array.IndexOf(Settings._sources, oldSource);
return(newIndex.CompareTo(oldIndex));
}
public static Azure_FileHash_Request ToHashRequest(this AniDB_File anifile)
{
Azure_FileHash_Request r = new Azure_FileHash_Request
{
ED2K = anifile.Hash,
CRC32 = anifile.CRC,
MD5 = anifile.MD5,
SHA1 = anifile.SHA1,
FileSize = anifile.FileSize
};
r.Username = ServerSettings.AniDB_Username;
if (ServerSettings.WebCache_Anonymous)
{
r.Username = Constants.AnonWebCacheUsername;
}
r.AuthGUID = string.IsNullOrEmpty(ServerSettings.WebCacheAuthKey) ? string.Empty : ServerSettings.WebCacheAuthKey;
return(r);
}
private static bool CheckAudioStreamCount(AniDB_File aniFile)
{
int streamCount = aniFile.File_AudioCodec.ToLowerInvariant()
.Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries)
.Length;
FileQualityFilterOperationType operationType = Settings.RequiredAudioStreamCountOperator;
switch (operationType)
{
case FileQualityFilterOperationType.EQUALS:
return(streamCount == Settings.RequiredAudioStreamCount);
case FileQualityFilterOperationType.GREATER_EQ:
return(streamCount >= Settings.RequiredAudioStreamCount);
case FileQualityFilterOperationType.LESS_EQ:
return(streamCount <= Settings.RequiredAudioStreamCount);
}
return(true);
}
private static bool CheckVideoCodec(AniDB_File aniFile)
{
string[] codecs = aniFile.File_VideoCodec.ToLowerInvariant()
.Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries);
if (codecs.Length == 0)
{
return(false);
}
FileQualityFilterOperationType operationType = Settings.RequiredVideoCodecOperator;
switch (operationType)
{
case FileQualityFilterOperationType.IN:
return(Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));
case FileQualityFilterOperationType.NOTIN:
return(!Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));
}
return(true);
}
private static bool CheckSubGroup(AniDB_File aniFile)
{
if (IsNullOrUnknown(aniFile))
{
return(false);
}
FileQualityFilterOperationType operationType = Settings.RequiredSubGroups.Operator;
switch (operationType)
{
case FileQualityFilterOperationType.IN:
return(Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) ||
Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
case FileQualityFilterOperationType.NOTIN:
return(!Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) &&
!Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
}
return(true);
}
private static int CompareResolutionTo(AniDB_File newFile, AniDB_File oldFile)
{
string oldRes = GetResolution(oldFile);
string newRes = GetResolution(newFile);
if (newRes == null || oldRes == null)
{
return(0);
}
if (!Settings._resolutions.Contains(newRes))
{
return(0);
}
if (!Settings._resolutions.Contains(oldRes))
{
return(-1);
}
int newIndex = Array.IndexOf(Settings._resolutions, newRes);
int oldIndex = Array.IndexOf(Settings._resolutions, oldRes);
return(newIndex.CompareTo(oldIndex));
}
private static bool CheckSource(AniDB_File aniFile)
{
if (IsNullOrUnknown(aniFile))
{
return(false);
}
FileQualityFilterOperationType operationType = Settings.RequiredSourceOperator;
var source = aniFile.File_Source.ToLowerInvariant();
if (FileQualityPreferences.SimplifiedSources.ContainsKey(source))
{
source = FileQualityPreferences.SimplifiedSources[source];
}
switch (operationType)
{
case FileQualityFilterOperationType.IN:
return(Settings._requiredsources.Item1.Contains(source));
case FileQualityFilterOperationType.NOTIN:
return(!Settings._requiredsources.Item1.Contains(source));
}
return(true);
}
private static Tuple <int, int> GetResolutionInternal(AniDB_File aniFile)
{
string[] res = aniFile.File_VideoResolution.Split('x');
if (res.Length != 2)
{
return(null);
}
int oldWidth = 0;
int oldHeight = 0;
if (!int.TryParse(res[0], out oldWidth))
{
return(null);
}
if (!int.TryParse(res[1], out oldHeight))
{
return(null);
}
if (oldWidth == 0 || oldHeight == 0)
{
return(null);
}
return(new Tuple <int, int>(oldWidth, oldHeight));
}
