public static async Task <(List <AddonData>, List <AddonData>)> FullProccess(HttpClient httpClient, List <CurseAddon> addons, int tries, List <AddonData> loadedData)
{
ConcurrentBag <AddonData> validAddonData = new ConcurrentBag <AddonData>();
ConcurrentBag <AddonData> NonValidAddonData = new ConcurrentBag <AddonData>();
List <Task <AddonData> > addonDataTasks = addons.Select(curseAddon => FromCurseToAddonData(httpClient, curseAddon, tries, loadedData)).ToList();
AddonData[] addonDatas = await Task.WhenAll(addonDataTasks);
List <Task> proccessTasks = addonDatas.Select(ad => ProccessAddonData(httpClient, ad).ContinueWith((t) =>
{
bool result = t.Result.Item1;
AddonData addonData = t.Result.Item2;
addonData.HasRetail = addonData.Downloads.Any(d => d.GameVersion.First().ToString() == "8");
addonData.HasClassic = addonData.Downloads.Any(d => d.GameVersion.First().ToString() == "1");
if (result)
{
validAddonData.Add(addonData);
logger.LogInformation("Match found for: " + addonData.ProjectName + " = " + addonData.FolderName);
}
else
{
NonValidAddonData.Add(addonData);
logger.LogInformation("No Match found for: " + addonData.ProjectName + " = " + addonData.FolderName);
}
addonData.Downloads = new List <Download>();
})).ToList();
await Task.WhenAll(proccessTasks);
return(validAddonData.ToList(), NonValidAddonData.ToList());
}
public StoreAddon(AddonData addonData)
{
AddonData = addonData;
Updated = DateTimeOffset.FromUnixTimeSeconds(addonData.UpdatedEpoch).UtcDateTime;
Created = DateTimeOffset.FromUnixTimeSeconds(addonData.CreatedEpoch).UtcDateTime;
UpdatedFormated = Updated.ToString("yyyy'-'MM'-'dd");
CreatedFormated = Created.ToString("yyyy'-'MM'-'dd");
}
private string GetIcon(AddonData addonData)
{
try
{
if (addonData.Attachments.Count() > 0)
{
return(addonData.Attachments.First().ThumbnailUrl);
}
}
catch (Exception exception)
{
Logger.Exception(exception);
}
const string defaultIcon = "https://www.macupdate.com/images/icons512/38553.png";
return(defaultIcon);
}
/// <summary>
/// Is called to initialize the object; usually after a set of other operations have been performed or if
/// the right time has come and other required steps have been performed.
/// </summary>
public void FinalizeDataHolder()
{
if (string.IsNullOrEmpty(DefaultName))
{
ContentMgr.OnInvalidDBData("NPCEntry has no name: " + this);
return;
}
if (Titles == null)
{
Titles = new string[(int)ClientLocale.End];
}
if (DefaultTitle == null)
{
DefaultTitle = "";
}
if (SpellGroupId != 0 && NPCMgr.PetSpells != null)
{
var spells = NPCMgr.PetSpells.Get(SpellGroupId) ?? Spell.EmptyArray;
foreach (var spell in spells)
{
AddSpell(spell);
}
}
if (MinMana > MaxMana)
{
MaxMana = MinMana;
}
if (MaxDamage > 0)
{
if (MinDamage < 1)
{
MinDamage = 1;
}
if (MaxDamage < MinDamage)
{
MaxDamage = MinDamage;
}
}
if (RangedMaxDamage > 0 && RangedMinDamage > 0)
{
if (RangedMaxDamage < RangedMinDamage)
{
RangedMaxDamage = RangedMinDamage;
}
if (RangedAttackTime == 0)
{
RangedAttackTime = AttackTime;
}
}
AggroBaseRange = AggroBaseRangeDefault;
NPCId = (NPCId)Id;
DefaultDecayDelayMillis = _DefaultDecayDelayMillis;
Family = NPCMgr.GetFamily(FamilyId);
if (Type == CreatureType.NotSpecified || VehicleEntry != null)
{
IsIdle = true;
}
if (Type == CreatureType.NotSpecified && UnitFlags.HasFlag((UnitFlags.Passive | UnitFlags.NotSelectable)))
{
IsEventTrigger = true;
IsIdle = false;
}
if (Resistances == null)
{
Resistances = new int[ItemConstants.MaxResCount];
}
SetFlagIndices = Utility.GetSetIndices((uint)NPCFlags);
// set/fix factions
HordeFaction = FactionMgr.Get(HordeFactionId);
AllianceFaction = FactionMgr.Get(AllianceFactionId);
if (HordeFaction == null)
{
HordeFaction = AllianceFaction;
HordeFactionId = AllianceFactionId;
}
else if (AllianceFaction == null)
{
AllianceFaction = HordeFaction;
AllianceFactionId = HordeFactionId;
}
if (AllianceFaction == null)
{
ContentMgr.OnInvalidDBData("NPCEntry has no valid Faction: " + this);
HordeFaction = AllianceFaction = NPCMgr.DefaultFaction;
HordeFactionId = AllianceFactionId = (FactionTemplateId)HordeFaction.Template.Id;
}
// speeds
if (SpeedFactor < 0.01)
{
SpeedFactor = 1;
}
if (WalkSpeed == 0)
{
WalkSpeed = NPCMgr.DefaultNPCWalkSpeed * SpeedFactor;
}
if (RunSpeed == 0)
{
RunSpeed = NPCMgr.DefaultNPCRunSpeed * SpeedFactor;
}
if (FlySpeed == 0)
{
FlySpeed = NPCMgr.DefaultNPCFlySpeed * SpeedFactor;
}
// Add all default spells
if (FixedSpells != null)
{
foreach (var spell in FixedSpells)
{
AddSpell(spell);
}
}
InstanceTypeHandlers = NPCMgr.GetNPCTypeHandlers(this);
SpawnTypeHandlers = NPCMgr.GetNPCSpawnTypeHandlers(this);
//ArrayUtil.PruneVals(ref DisplayIds);
if (EquipmentId != 0)
{
Equipment = NPCMgr.GetEquipment(EquipmentId);
}
ModelInfos = new UnitModelInfo[DisplayIds.Length];
GeneratesXp = (Type != CreatureType.Critter && Type != CreatureType.None && !ExtraFlags.HasFlag(UnitExtraFlags.NoXP));
var x = 0;
for (var i = 0; i < DisplayIds.Length; i++)
{
var did = DisplayIds[i];
if (did > 0)
{
var model = UnitMgr.GetModelInfo(did);
if (model != null)
{
ModelInfos[x++] = model;
}
}
}
if (x == 0)
{
ContentMgr.OnInvalidDBData("NPCEntry has no valid DisplayId: {0} ({1})", this, DisplayIds.ToString(", "));
return;
}
if (TrainerTemplateId != 0)
{
if (!NPCMgr.TrainerSpellTemplates.ContainsKey(TrainerTemplateId))
{
ContentMgr.OnInvalidDBData("NPCEntry has invalid TrainerTemplateId: {0} ({1})", this, TrainerTemplateId);
}
else
{
if (TrainerEntry == null)
{
TrainerEntry = new TrainerEntry();
}
foreach (var trainerSpell in NPCMgr.TrainerSpellTemplates[TrainerTemplateId])
{
TrainerEntry.AddSpell(trainerSpell);
}
}
}
if (AddonData != null)
{
AddonData.InitAddonData(this);
}
if (x < ModelInfos.Length)
{
Array.Resize(ref ModelInfos, x);
}
// add to container
if (Id < NPCMgr.Entries.Length)
{
NPCMgr.Entries[Id] = this;
}
else
{
NPCMgr.CustomEntries[Id] = this;
}
++NPCMgr.EntryCount;
if (BrainCreator == null)
{
BrainCreator = DefaultBrainCreator;
}
if (NPCCreator == null)
{
NPCCreator = DefaultCreator;
}
}
public static AddonData GetAddonData(string workshopAddonId, bool cacheIgnore = false)
{
string currentDirectoryPath = System.AppDomain.CurrentDomain.BaseDirectory;
string fileCachePath = Path.Combine(currentDirectoryPath, "cache.json");
List <AddonData> caches = new List <AddonData>();
if (!cacheIgnore)
{
if (File.Exists(fileCachePath))
{
string fileJson = File.ReadAllText(fileCachePath);
caches = JsonConvert.DeserializeObject <List <AddonData> >(fileJson);
AddonData getAddonsCache = caches.Find(x => x.Uid == workshopAddonId);
if (getAddonsCache != null)
{
return(getAddonsCache);
}
}
}
try
{
AddonData addonData = new AddonData();
HtmlDocument htmlDocument = new HtmlDocument();
string htmlBody = null;
using (WebClient client = new WebClient())
{
htmlBody = client.DownloadString("https://steamcommunity.com/sharedfiles/filedetails/?id=" + workshopAddonId.ToString());
}
if (htmlBody == null)
{
return(new AddonData());
}
htmlDocument.LoadHtml(htmlBody);
HtmlNode docNode = htmlDocument.DocumentNode;
addonData.Title = docNode.SelectSingleNode("//div[@class='workshopItemTitle']").InnerText;
addonData.Description = docNode.SelectSingleNode("//div[@class='workshopItemDescription']").InnerText;
try
{
addonData.ImageUrl = docNode.SelectSingleNode("//img[@id='previewImageMain']").Attributes["src"].Value;
}
catch
{
addonData.ImageUrl = docNode.SelectSingleNode("//img[@id='previewImage']").Attributes["src"].Value;
}
int workshop_tags_num = 0;
foreach (HtmlNode workshopTag in docNode.SelectNodes("//div[@class='workshopTags']").Descendants("a"))
{
if (workshop_tags_num <= 1)
{
addonData.Types.Add(workshopTag.InnerText);
}
else
{
addonData.Tags.Add(workshopTag.InnerText);
}
workshop_tags_num++;
}
int workshop_details_num = 0;
foreach (HtmlNode workshopDetails in docNode.SelectNodes("//div[@class='detailsStatRight']"))
{
if (workshop_details_num == 0)
{
addonData.FileSize = workshopDetails.InnerText;
}
if (workshop_details_num == 1)
{
addonData.UploadDate = workshopDetails.InnerText;
}
if (workshop_details_num == 2)
{
addonData.UpdateDate = workshopDetails.InnerText;
}
workshop_details_num++;
}
HtmlNodeCollection cells = docNode.SelectNodes("//table[@class='stats_table']/tr/td");
addonData.UniqueVisitors = cells[0].InnerText;
addonData.Subscribers = cells[2].InnerText;
addonData.Favorites = cells[4].InnerText;
addonData.Uid = workshopAddonId;
if (caches.Count == 0 && File.Exists(fileCachePath))
{
string fileJson = File.ReadAllText(fileCachePath);
caches = JsonConvert.DeserializeObject <List <AddonData> >(fileJson);
}
if (cacheIgnore)
{
bool isExists = false;
for (int i = 0; i < caches.Count; i++)
{
if (caches[i].Uid == workshopAddonId)
{
caches[i] = addonData;
isExists = true;
break;
}
}
if (!isExists)
{
caches.Add(addonData);
}
File.WriteAllText(fileCachePath, JsonConvert.SerializeObject(caches, Formatting.Indented));
}
else
{
caches.Add(addonData);
File.WriteAllText(fileCachePath, JsonConvert.SerializeObject(caches, Formatting.Indented));
}
return(addonData);
}
catch (Exception ex)
{
//Console.WriteLine("Parsing addon webpage error:\n" + ex);
return(new AddonData());
}
}
/***** INSTALL *****/
/// <summary>
/// Performs archive extraction and file IO operations to install the downloaded addon.
/// </summary>
private void Install()
{
viewModel.ProgBarLabel = "Installing " + addon_info.addon_name;
if (addon_info.download_type == "archive")
{
if (Directory.Exists(addon_expanded_path))
{
Directory.Delete(addon_expanded_path, true);
}
ZipFile.ExtractToDirectory(fileName, addon_expanded_path);
if (addon_info.install_mode != "arc")
{
FileSystem.CopyDirectory(addon_expanded_path, addon_install_path, true);
}
else
{
if (!Directory.Exists(Path.Combine(addon_install_path, "arcdps")))
{
Directory.CreateDirectory(Path.Combine(addon_install_path, "arcdps"));
}
File.Copy(Path.Combine(addon_expanded_path, addon_info.plugin_name), Path.Combine(Path.Combine(addon_install_path, "arcdps"), addon_info.plugin_name), true);
}
}
else
{
if (addon_info.install_mode != "arc")
{
if (!Directory.Exists(Path.Combine(addon_install_path, addon_info.folder_name)))
{
Directory.CreateDirectory(Path.Combine(addon_install_path, addon_info.folder_name));
}
FileSystem.CopyFile(fileName, Path.Combine(Path.Combine(addon_install_path, addon_info.folder_name), Path.GetFileName(fileName)), true);
}
else
{
if (!Directory.Exists(Path.Combine(addon_install_path, "arcdps")))
{
Directory.CreateDirectory(Path.Combine(addon_install_path, "arcdps"));
}
FileSystem.CopyFile(fileName, Path.Combine(Path.Combine(addon_install_path, "arcdps"), Path.GetFileName(fileName)), true);
}
}
//removing download from temp folder to avoid naming clashes
FileSystem.DeleteFile(fileName);
var addonConfig = _configurationManager.UserConfig.AddonsList.FirstOrDefault(a => a.Name == addon_name);
if (addonConfig != null)
{
addonConfig.Version = latestVersion;
}
else
{
var newAddonConfig = new AddonData {
Name = addon_name, Installed = true, Version = latestVersion
};
_configurationManager.UserConfig.AddonsList.Add(newAddonConfig);
}
_configurationManager.SaveConfiguration();
}
private static async Task <AddonData> FromCurseToAddonData(HttpClient httpClient, CurseAddon curseAddon, int tries, List <AddonData> loadedData)
{
List <AddonData> foundDataList = loadedData.Where(ad => ad.ProjectName.Equals(curseAddon.AddonURL)).ToList();
if (foundDataList.Count == 1)
{
AddonData foundData = foundDataList[0];
foundData.NrOfDownloads = curseAddon.Downloads;
foundData.UpdatedEpoch = curseAddon.UpdatedEpoch;
foundData.CreatedEpoch = curseAddon.CreatedEpoch;
foundData.Description = curseAddon.Description;
foundData.Title = curseAddon.Title;
try
{
foundData.Downloads = await Pure.Version.DownloadVersionsFor(httpClient, foundData.ProjectName);
}
catch (Exception e)
{
logger.LogError(e, nameof(FromCurseToAddonData) + " error getting versions");
}
AddonData copy = new AddonData()
{
CreatedEpoch = foundData.CreatedEpoch,
Title = foundData.Title,
Description = foundData.Description,
Downloads = foundData.Downloads,
Files = foundData.Files,
FolderName = foundData.FolderName,
NrOfDownloads = foundData.NrOfDownloads,
ProjectName = foundData.ProjectName,
Size = foundData.Size,
SubFolders = foundData.SubFolders,
UpdatedEpoch = foundData.UpdatedEpoch
};
return(copy);
}
if (foundDataList.Count > 1)
{
logger.LogInformation("foundDataList.Count=" + foundDataList.Count + " for " + curseAddon.AddonURL);
}
AddonData addonData = curseAddon.toAddonData();
for (int i = 0; i < tries; i++)
{
try
{
addonData.Downloads = await Pure.Version.DownloadVersionsFor(httpClient, addonData.ProjectName);
if (addonData.Downloads.Count > 1)
{
return(addonData);
}
}
catch (Exception e)
{
logger.LogError(e, nameof(FromCurseToAddonData) + " try: " + i + "/" + tries);
}
}
return(addonData);
}
public static async Task <(bool, AddonData)> ProccessAddonData(HttpClient httpClient, AddonData addonData)
{
if (!string.IsNullOrEmpty(addonData.FolderName))
{
return(true, addonData);
}
bool found = false;
string zipFile = string.Empty;
try
{
zipFile = await Update.DLWithHttpProgress(httpClient, addonData.Downloads[0]);
}
catch (Exception e)
{
logger.LogError(e, "Something went wrong in " + nameof(ProccessAddonData) + " for " + addonData.ProjectName);
return(found, addonData);
}
if (string.IsNullOrEmpty(zipFile) || !File.Exists(zipFile))
{
logger.LogError("No zipFile found for " + addonData.ProjectName);
return(found, addonData);
}
FileInfo fileInfo = new FileInfo(zipFile);
addonData.Size = fileInfo.Length;
try
{
(int entries, List <string> folders) = Update.UpdateAddon2(zipFile);
addonData.Files = entries;
if (folders.Count == 1)
{
addonData.FolderName = folders[0];
found = true;
}
else
{
foreach (string folder in folders)
{
string lowered = folder.ToLower();
if (PROJECT_URLS.TryGetValue(lowered, out string mapped))
{
if (mapped.Equals(addonData.ProjectName))
{
found = true;
addonData.FolderName = folder;
break;
}
}
}
if (!found)
{
HashSet <string> urlNames = new HashSet <string>()
{
addonData.ProjectName,
addonData.ProjectName.Replace("-", ""),
addonData.ProjectName.Replace("_", ""),
addonData.ProjectName.Replace("_", "-"),
addonData.ProjectName.Replace("-", "_")
};
foreach (string folder in folders)
{
string lowered = folder.ToLower();
HashSet <string> folderNames = new HashSet <string>()
{
lowered,
lowered.Replace(" ", "-"),
lowered.Replace("_", "-")
};
if (folderNames.Contains(addonData.ProjectName))
{
found = true;
addonData.FolderName = folder;
break;
}
if (urlNames.Contains(lowered))
{
found = true;
addonData.FolderName = folder;
break;
}
}
}
}
addonData.SubFolders = folders.Where(f => !f.Equals(addonData.FolderName)).ToHashSet();
if (found)
{
File.Delete(zipFile);
Directory.Delete(zipFile.Replace(".zip", ""), true);
}
return(found, addonData);
}
catch (Exception e)
{
logger.LogError(e, "Someting went wrong for " + addonData.ProjectName);
return(found, addonData);
}
}
