public async Task <PotentialAddon> Search(Uri addonUri, WowClientType clientType)
{
var repoPath = addonUri.LocalPath;
var repoExtension = Path.GetExtension(repoPath);
if (string.IsNullOrEmpty(repoPath) || !string.IsNullOrEmpty(repoExtension))
{
throw new InvalidUrlException($"Invlaid URL: {addonUri}");
}
var results = await GetReleases(repoPath);
var latestRelease = GetLatestRelease(results);
var asset = GetValidAsset(latestRelease, clientType);
if (asset == null)
{
throw new NoReleaseFoundException();
}
var repository = await GetRepository(repoPath);
var author = repository.Owner.Login;
var authorImageUrl = repository.Owner.AvatarUrl;
var potentialAddon = new PotentialAddon
{
Author = author,
DownloadCount = asset.DownloadCount,
ExternalId = repoPath,
ExternalUrl = latestRelease.Url,
Name = asset.Name,
ProviderName = Name,
ThumbnailUrl = authorImageUrl
};
return(potentialAddon);
}
/// <summary>
/// This is a basic method, curse api does not search via slug, so you have to get lucky basically.
/// Could pre-make a map for slug to addon if wanted.
/// </summary>
/// <param name="addonUri"></param>
/// <param name="clientType"></param>
/// <returns></returns>
public async Task <PotentialAddon> Search(Uri addonUri, WowClientType clientType)
{
var addonSlug = addonUri.LocalPath.Split('/').Last();
var searchword = addonSlug.Split("-")[0];
var response = await GetSearchResults(searchword);
var result = response.FirstOrDefault(res => res.Slug == addonSlug);
if (result == null)
{
return(null);
}
var latestFiles = GetLatestFiles(result, clientType);
if (!latestFiles.Any())
{
return(null);
}
return(GetPotentialAddon(result));
}
public async Task Scan(
WowClientType clientType,
AddonChannelType addonChannelType,
IEnumerable <AddonFolder> addonFolders)
{
Log.Debug($"{Name} Scanning {addonFolders.Count()} addons");
foreach (var addonFolder in addonFolders)
{
if (string.IsNullOrEmpty(addonFolder.Toc.WowInterfaceId))
{
continue;
}
var details = await GetAddonDetails(addonFolder.Toc.WowInterfaceId);
addonFolder.MatchingAddon = new Addon
{
Author = details.Author,
AutoUpdateEnabled = false,
ChannelType = addonChannelType,
ClientType = clientType,
DownloadUrl = details.DownloadUri,
ExternalId = details.Id.ToString(),
ExternalUrl = GetAddonUrl(details),
FolderName = addonFolder.Name,
GameVersion = string.Empty,
InstalledAt = DateTime.UtcNow,
InstalledFolders = addonFolder.Name,
InstalledVersion = addonFolder.Toc.Version,
IsIgnored = false,
LatestVersion = details.Version,
Name = details.Title,
ProviderName = Name,
ThumbnailUrl = GetThumbnailUrl(details)
};
}
}
private Addon GetAddon(
WowClientType clientType,
AddonChannelType addonChannelType,
AddonFolder addonFolder,
CurseSearchResult searchResult)
{
if (addonFolder == null || searchResult == null)
{
return(null);
}
var currentVersion = addonFolder.Toc.Version;
var latestFile = GetLatestFiles(searchResult, clientType).First();
var authors = GetAuthor(searchResult);
return(new Addon
{
Author = authors,
Name = searchResult.Name,
ChannelType = addonChannelType,
AutoUpdateEnabled = false,
ClientType = clientType,
DownloadUrl = latestFile.DownloadUrl,
ExternalUrl = searchResult.WebsiteUrl,
ExternalId = searchResult.Id.ToString(),
FolderName = addonFolder.Name,
GameVersion = latestFile.GameVersion.FirstOrDefault(),
InstalledAt = DateTime.Now,
InstalledFolders = string.Join(",", GetFolderNames(latestFile)),
InstalledVersion = currentVersion,
IsIgnored = false,
LatestVersion = latestFile.DisplayName,
ProviderName = Name,
ThumbnailUrl = GetThumbnailUrl(searchResult)
});
}
private async Task <IEnumerable <TukUiAddon> > GetAllAddons(WowClientType clientType)
{
var cacheKey = GetCacheKey(clientType);
if (_cache.TryGetValue(cacheKey, out var cachedAddons))
{
return(cachedAddons as IEnumerable <TukUiAddon>);
}
var query = GetAddonsSuffix(clientType);
var result = await ApiUrl
.SetQueryParam(query, "all")
.GetJsonAsync <List <TukUiAddon> >();
if (clientType.IsRetail())
{
result.Add(await GetTukUiRetailAddon());
result.Add(await GetElvUiRetailAddon());
}
_cache.CacheForAbsolute(cacheKey, result, TimeSpan.FromMinutes(10));
return(result);
}
public async Task <List <Addon> > MapAll(IEnumerable <AddonFolder> addonFolders, WowClientType clientType)
{
var results = new Dictionary <string, Addon>();
foreach (var addonFolder in addonFolders)
{
try
{
var addon = await Map(addonFolder.Toc.Title, addonFolder.Name, clientType);
if (addon == null)
{
continue;
}
results[addon.Name] = addon;
}
catch (Exception ex)
{
Log.Error(ex, $"Failed to map addon folder {addonFolder.Name}");
}
}
return(results.Values
.OrderBy(v => v.Name)
.ToList());
}
private async Task <List <Addon> > GetLocalAddons(WowClientType clientType)
{
var addonFolders = await _warcraftService.ListAddons(clientType);
return(await MapAll(addonFolders, clientType));
}
public void SetClientDefaultAutoUpdate(WowClientType clientType, bool autoUpdate)
{
var preferenceKey = GetClientDefaultAutoUpdateKey(clientType);
SetPreference(preferenceKey, autoUpdate.ToString());
}
public string GetClientLocation(WowClientType clientType)
{
var preference = GetClientLocationPreference(clientType);
return(preference?.Value ?? string.Empty);
}
public Task <IEnumerable <AddonSearchResult> > Search(string addonName, string folderName, WowClientType clientType, string nameOverride = null)
{
return(Task.FromResult(new List <AddonSearchResult>() as IEnumerable <AddonSearchResult>));
}
public Task <IList <PotentialAddon> > GetFeaturedAddons(WowClientType clientType)
{
return(Task.FromResult(new List <PotentialAddon>() as IList <PotentialAddon>));
}
public async Task <IEnumerable <AddonSearchResult> > Search(string addonName, string folderName, WowClientType clientType, string nameOverride = null)
{
var results = new List <AddonSearchResult>();
try
{
var addons = await SearchAddons(clientType, addonName);
var addon = addons.FirstOrDefault();
if (addon != null)
{
results.Add(ToSearchResult(addon, folderName));
}
}
catch (Exception ex)
{
_analyticsService.Track(ex, "Failed to search TukUi");
}
return(results);
}
public Task <PotentialAddon> Search(Uri addonUri, WowClientType clientType)
{
throw new NotImplementedException();
}
public async Task <IEnumerable <AddonSearchResult> > Search(string addonName, string folderName, WowClientType clientType, string nameOverride = null)
{
var results = new List <AddonSearchResult>();
try
{
var addons = await GetAllAddons(clientType);
var addon = addons
.Where(a => a.Name.Equals(addonName, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
if (addon != null)
{
results.Add(ToSearchResult(addon, folderName));
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to search TukUi");
}
return(results);
}
public async Task <AddonSearchResult> GetById(
string addonId,
WowClientType clientType)
{
return(null);
}
public async Task <IList <PotentialAddon> > GetFeaturedAddons(WowClientType clientType)
{
return(new List <PotentialAddon>());
}
public Task <AddonSearchResult> Search(Uri addonUri, WowClientType clientType)
{
throw new NotImplementedException();
}
public static bool IsRetail(this WowClientType clientType)
{
return(clientType == WowClientType.Retail ||
clientType == WowClientType.RetailPtr ||
clientType == WowClientType.Beta);
}
private IList <CurseSearchResult> FilterClientType(IEnumerable <CurseSearchResult> results, WowClientType clientType)
{
var clientTypeStr = GetClientTypeString(clientType);
return(results
.Where(r => r.LatestFiles.Any(f => DoesFileMatchClientType(f, clientTypeStr)))
.ToList());
}
public Addon GetByExternalId(string externalId, WowClientType clientType)
{
return(Query(addons =>
addons.FirstOrDefault(ad => ad.ClientType == clientType && ad.ExternalId == externalId)));
}
public Task <IEnumerable <PotentialAddon> > Search(string query, WowClientType clientType)
{
return(Task.FromResult(new List <PotentialAddon>() as IEnumerable <PotentialAddon>));
}
private List <Addon> GetAllStoredAddons(WowClientType clientType)
{
return(_addonRepository.Query(table => table.Where(a => a.ClientType == clientType)).ToList());
}
public static bool IsClassic(this WowClientType clientType)
{
return(clientType == WowClientType.Classic ||
clientType == WowClientType.ClassicPtr);
}
public void SetClientAddonChannelType(WowClientType clientType, AddonChannelType channelType)
{
var preferenceKey = GetClientDefaultAddonChannelKey(clientType);
SetPreference(preferenceKey, channelType.ToString());
}
private void RemoveAddons(WowClientType clientType)
{
var addons = GetAllStoredAddons(clientType);
_addonRepository.DeleteItems(addons);
}
public void SetLastSelectedClientType(WowClientType clientType)
{
SetPreference(Constants.Preferences.LastSelectedClientTypeKey, clientType.ToString());
}
public bool IsInstalled(string externalId, WowClientType clientType)
{
return(_addonRepository.GetByExternalId(externalId, clientType) != null);
}
private string GetClientDefaultAddonChannelKey(WowClientType clientType)
{
return($"{clientType}{Constants.Preferences.ClientDefaultAddonChannelSuffix}".ToLower());
}
private Preference GetClientLocationPreference(WowClientType clientType)
{
var preferenceKey = GetClientLocationPreferenceKey(clientType);
return(_preferenceRepository.FindByKey(preferenceKey));
}
private string GetClientDefaultAutoUpdateKey(WowClientType clientType)
{
return($"{clientType}{Constants.Preferences.ClientDefaultAutoUpdateSuffix}".ToLower());
}
