public MediaInfoResolverTests()
{
// prep BaseItem and Video for calls made that expect managers
Video.LiveTvManager = Mock.Of <ILiveTvManager>();
var applicationPaths = new Mock <IServerApplicationPaths>().Object;
var serverConfig = new Mock <IServerConfigurationManager>();
serverConfig.Setup(c => c.ApplicationPaths)
.Returns(applicationPaths);
BaseItem.ConfigurationManager = serverConfig.Object;
// build resolver to test with
var englishCultureDto = new CultureDto("English", "English", "en", new[] { "eng" });
var localizationManager = new Mock <ILocalizationManager>(MockBehavior.Loose);
localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"en.*", RegexOptions.IgnoreCase)))
.Returns(englishCultureDto);
_localizationManager = localizationManager.Object;
var mediaEncoder = new Mock <IMediaEncoder>(MockBehavior.Strict);
mediaEncoder.Setup(me => me.GetMediaInfo(It.IsAny <MediaInfoRequest>(), It.IsAny <CancellationToken>()))
.Returns <MediaInfoRequest, CancellationToken>((_, _) => Task.FromResult(new MediaBrowser.Model.MediaInfo.MediaInfo
{
MediaStreams = new List <MediaStream>
{
new()
}
}));
private string GetLanguageId(CultureDto cultureDto)
{
var search = cultureDto?.TwoLetterISOLanguageName ?? "";
if (search != "pt-br")
{
search = search.Split(new[] { '-' }, 2)?[0] ?? search;
}
_logger.Info("Searching language: " + search);
var langMap = new Dictionary <string, string>()
{
{ "pt-br", "1" },
{ "pt", "2" },
{ "en", "3" },
{ "fr", "4" },
{ "de", "5" },
{ "ja", "6" },
{ "da", "7" },
{ "nb", "8" },
{ "sv", "9" },
{ "es", "10" },
{ "ar", "11" },
{ "cs", "12" },
{ "zh", "13" },
{ "ko", "14" },
{ "bg", "15" },
{ "it", "16" },
{ "pl", "17" }
};
string output;
return(langMap.TryGetValue(search, out output) ? output : null);
}
public async Task CreateAsync(CultureDto cultureDto)
{
var culture = _mapper.Map <Culture>(cultureDto);
culture.Id = Guid.NewGuid();
await _repository.CreateAsync(culture);
}
public virtual async Task <IActionResult> CultureDelete([FromBody] CultureDto body)
{
_dbContext.RefreshFullDomain();
await _genService.DeleteAsync(body, (x => { return(x.Cultureid == body.Cultureid); }));
return(new ObjectResult(true));
}
public virtual async Task <IActionResult> CultureUpdatePost([FromBody] CultureDto body)
{
_dbContext.RefreshFullDomain();
var workflowById = await _genService.UpdateAsync(body, (x => { return(x.Cultureid == body.Cultureid); }));
return(new ObjectResult(workflowById));
}
public MetadataEditorInfo()
{
ParentalRatingOptions = new ParentalRating[] { };
Countries = new CountryInfo[] { };
Cultures = new CultureDto[] { };
ExternalIdInfos = new ExternalIdInfo[] { };
ContentTypeOptions = Array.Empty <NameValuePair>();
}
public async Task UpdateAsync(CultureDto cultureDto)
{
var culture = await _repository.GetAsync(cultureDto.Id);
if (culture == null)
{
throw new GreenFieldNotFoundException();
}
culture = _mapper.Map <Culture>(cultureDto);
await _repository.UpdateAsync(culture);
}
public async Task UpdateAsync(CultureDto dto)
{
var culture =
await _unitOfWork.CultureRepository.FindAsync(dto.Id);
culture.IsActive = dto.IsActive;
culture.Name = dto.Name;
culture.DisplayName = dto.DisplayName;
culture.NativeName = dto.NativeName;
culture.Lcid = dto.Lcid;
await _unitOfWork.CultureRepository.UpdateAsync(culture);
await _unitOfWork.SaveAsync();
}
public ExternalPathParserTests()
{
var englishCultureDto = new CultureDto("English", "English", "en", new[] { "eng" });
var frenchCultureDto = new CultureDto("French", "French", "fr", new[] { "fre", "fra" });
var localizationManager = new Mock <ILocalizationManager>(MockBehavior.Loose);
localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"en.*", RegexOptions.IgnoreCase)))
.Returns(englishCultureDto);
localizationManager.Setup(lm => lm.FindLanguageInfo(It.IsRegex(@"fr.*", RegexOptions.IgnoreCase)))
.Returns(frenchCultureDto);
_audioPathParser = new ExternalPathParser(new NamingOptions(), localizationManager.Object, DlnaProfileType.Audio);
_subtitlePathParser = new ExternalPathParser(new NamingOptions(), localizationManager.Object, DlnaProfileType.Subtitle);
}
public async Task <CultureDto> GetByIdAsync(int id)
{
var culture =
await _unitOfWork.CultureRepository.FindAsync(id);
var result = new CultureDto
{
Id = culture.Id,
DisplayName = culture.DisplayName,
IsActive = culture.IsActive,
Lcid = culture.Lcid,
Name = culture.Name,
NativeName = culture.NativeName,
};
return(result);
}
public async Task <int> InsertAsync(CultureDto dto)
{
var culture = new Culture
{
IsActive = dto.IsActive,
Name = dto.Name,
DisplayName = dto.DisplayName,
Lcid = dto.Lcid,
NativeName = dto.NativeName,
};
var entity =
await _unitOfWork.CultureRepository.InsertAsync(culture);
await _unitOfWork.SaveAsync();
return(entity.Id);
}
public async Task <IEnumerable <RemoteSubtitleInfo> > Search(
Guid idMedia,
CancellationToken cancellationToken,
CultureDto lang = null,
string query = "-",
string page = "-",
string itemId = "-"
)
{
if (lang == null)
{
_logger.Error("No language defined.");
return(Array.Empty <RemoteSubtitleInfo>());
}
var requestOptions = new HttpRequestOptions()
{
Url = string.Format(URL_BASE + "/legenda/busca/{0}/{1}/-/{2}/{3}", HttpUtility.HtmlEncode(query), GetLanguageId(lang), page, itemId),
CancellationToken = cancellationToken,
Referer = URL_BASE + "/busca/" + query
};
requestOptions.RequestHeaders.Add("X-Requested-With", "XMLHttpRequest");
using (var stream = await _httpClient.Get(requestOptions))
{
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(ParseHtml(idMedia, response, lang)
.OrderBy(sub => LegendasTVIdParts.parse(sub.Id).sortingOverride)
.ThenByDescending(sub => sub.CommunityRating)
.ThenByDescending(sub => sub.DownloadCount));
}
}
}
private IEnumerable <RemoteSubtitleInfo> ParseHtml(Guid idMedia, string html, CultureDto lang)
{
var doc = new HtmlDocument();
doc.LoadHtml(html);
var subtitleNodes = doc.DocumentNode.SelectNodes("//div[contains(@class, 'list_element')]//article/div") ?? new HtmlNodeCollection(doc.DocumentNode);
foreach (var subtitleNode in subtitleNodes)
{
var link = subtitleNode.SelectSingleNode(".//a");
var data = subtitleNode.SelectSingleNode(".//p[contains(@class, 'data')]");
var dataMatch = Regex.Match(data.InnerText.Trim(), @"^\D*?(\d+) +downloads,.*nota +(\d+) *,.*em *(.+)$").Groups;
var downloadId = Regex.Match(link.Attributes["href"].Value, @"^.*download\/(.*?)\/.*$").Groups[1].Value;
var name = link.InnerText;
yield return(new RemoteSubtitleInfo()
{
Id = new LegendasTVIdParts()
{
downloadId = downloadId,
name = name,
language = lang.TwoLetterISOLanguageName,
sortingOverride = subtitleNode.HasClass("destaque") ? -1 : 0,
idMedia = idMedia
}.fullId,
Name = name,
DownloadCount = int.Parse(dataMatch[1].Value),
CommunityRating = float.Parse(dataMatch[2].Value),
DateCreated = DateTimeOffset.ParseExact("15/11/2019 - 12:43", "dd/MM/yyyy - HH:mm", CultureInfo.InvariantCulture),
Format = "srt",
IsForced = false,
IsHashMatch = false,
ProviderName = this.Name,
Author = data.SelectSingleNode("//a")?.InnerText,
ThreeLetterISOLanguageName = lang.ThreeLetterISOLanguageName
});
}
}
public Task<CultureDto> UpdateAsync([FromBody] CultureDto updateCulture)
{
return _cultureService.UpdateAsync(updateCulture);
}
public Task<CultureDto> CreateAsync([FromBody] CultureDto createCulture)
{
return _cultureService.CreateAsync(createCulture);
}
