public void Run(FileRequestResult dataRes)
{
if (dataRes != FileRequestResult.Success)
{
PublishPrice = false;
}
var filterOutFolder = Path.GetTempPath() + "filterGenerationResult";
var repoFolder = filterOutFolder + "\\" + RepoName;
LoggingFacade.LogInfo($"Tempfolder prepared");
if (!Directory.Exists(filterOutFolder))
{
Directory.CreateDirectory(filterOutFolder);
}
// clone/pull the repo. after that, we will edit these existing files by generating the new versions
// and push the update as the actual small changes.
if (Directory.Exists(repoFolder))
{
LoggingFacade.LogInfo($"Repo folder existing... pulling");
RunCommand(filterOutFolder, "git", "branch --set-upstream-to=origin/master master");
using (var repo = new Repository(repoFolder))
{
var options = new PullOptions();
var author = Environment.GetEnvironmentVariable("author", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
var email = Environment.GetEnvironmentVariable("email", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
Commands.Pull(repo, new Signature(author, email, DateTimeOffset.Now), options);
LoggingFacade.LogInfo($"Pulling done");
}
}
else
{
LoggingFacade.LogInfo($"Repo folder not existing... cloning");
Repository.Clone("https://github.com/NeverSinkDev/" + RepoName + ".git", repoFolder);
LoggingFacade.LogInfo($"Cloning done!");
}
// create filter
LoggingFacade.LogInfo($"Performing filter generation operations");
FilterWriter.WriteFilter(this.Filter, true, repoFolder + "\\", Path.GetDirectoryName(GenerateFilters.DataFiles.FilterStyleFilesPaths.First().Value) + "\\");
LoggingFacade.LogInfo($"Performing filter generation operations: DONE");
LoggingFacade.LogInfo($"Starting publishing!");
PushToFTP("www", repoFolder, "NeverSink_AutoEcoUpdate_" + GenerateFilters.DataFiles.LeagueType);
LoggingFacade.LogInfo($"Publishing to filterblade: done");
PushToFTP("beta", repoFolder, "NeverSink_AutoEcoUpdate_" + GenerateFilters.DataFiles.LeagueType);
LoggingFacade.LogInfo($"Publishing to filterblade-beta: done");
PushToGit(repoFolder, PublishPrice);
LoggingFacade.LogInfo($"Publishing to GitHub: done");
UploadToPoe(repoFolder);
LoggingFacade.LogInfo($"PoeUpload: done");
// no cleanUp -> we keep this folder here and just pull/push whenever we generate new filters
}
private void UploadToPoe_Single(string filterId, string accessToken, string descr, string filterContent)
{
var url = "https://www.pathofexile.com/api/item-filter/" + filterId + "?access_token=" + accessToken;
var body = new
{
filter = filterContent,
filterID = filterId,
description = descr,
version = FilterAccessFacade.GetInstance().PrimaryFilter.GetHeaderMetaData("VERSION")
};
LoggingFacade.LogInfo($"[PoeUpload] Sending request...");
var resp = FileDownloader.StaticHttpClient.PostAsJsonAsync(url, body);
resp.Wait();
if (resp.Result.StatusCode != HttpStatusCode.OK)
{
LoggingFacade.LogError($"[PoeUpload] Error: " + resp.Result.StatusCode);
}
else
{
LoggingFacade.LogInfo($"[PoeUpload] Success");
}
}
private Filter PerformFilterWork()
{
var outputFolder = Configuration.AppSettings["Output Folder"];
var defaultPath = outputFolder + "\\Unnamed filter - SEED (SeedFilter) .filter";
string filePath;
if (System.IO.File.Exists(defaultPath))
{
filePath = defaultPath;
}
else
{
this.SelectSeedFilterFile(null, null);
return(this.FilterAccessFacade.PrimaryFilter);
}
LoggingFacade.LogInfo($"Loading Filter: {filePath}");
this.FilterRawString = FileWork.ReadLinesFromFile(filePath);
if (this.FilterRawString == null || this.FilterRawString.Count < 4500)
{
LoggingFacade.LogWarning($"Loading Filter: Filter Content Suspiciously Short");
}
return(new Filter(this.FilterRawString));
}
public void ApplyAllSuggestions()
{
LoggingFacade.LogInfo("Applying All Suggestions!");
this.Changelog.Clear();
foreach (var section in this.Suggestions)
{
this.Changelog.Add(section.Key, new List <TieringChange>());
this.ApplyAllSuggestionsInSection(section.Key);
}
var keys = this.Changelog.Keys.ToList();
foreach (var section in keys)
{
this.Changelog[section] = this.Changelog[section].OrderBy(x => x.BaseType).ToList();
}
if (this.generatePrimitiveReport)
{
var report = this.GeneratePrimitiveReport();
var seedPath = this.WriteFolder + "tierlistchanges\\" + DateTime.Today.ToString().Replace("/", "-").Replace(":", "") + ".txt";
FileWork.WriteTextAsync(seedPath, report);
}
}
public static void AdjustPricingInformation()
{
SuperTierBreakPoint = Math.Max(1f * ExaltedOrbPrice, 75);
// Uniques
UniqueT1BreakPoint = UniqueT1Base + UniqueExaltedOrbInfluence * T1ExaltedInfluence * ExaltedOrbPrice;
UniqueT2BreakPoint = UniqueT2Base + UniqueExaltedOrbInfluence * T2ExaltedInfluence * ExaltedOrbPrice;
// BaseTypes
BaseTypeT1BreakPoint = BaseTypeT1Base + BasesExaltedOrbInfluence * T1ExaltedInfluence * ExaltedOrbPrice;
BaseTypeT2BreakPoint = BaseTypeT2Base + BasesExaltedOrbInfluence * T2ExaltedInfluence * ExaltedOrbPrice;
// Divination
DiviT1BreakPoint = DiviT1Base + DivinationExaltedOrbInfluence * T1ExaltedInfluence * ExaltedOrbPrice;
DiviT2BreakPoint = DiviT2Base + DivinationExaltedOrbInfluence * T2ExaltedInfluence * ExaltedOrbPrice;
DiviT3BreakPoint = DiviT3Base + DivinationExaltedOrbInfluence * T3ExaltedInfluence * ExaltedOrbPrice;
DiviT5BreakPoint = DiviT5Base + DivinationExaltedOrbInfluence * T5ExaltedInfluence * ExaltedOrbPrice;
// Misc
MiscT1BreakPoint = MiscT1Base + MiscExaltedOrbInfluence * T1ExaltedInfluence * ExaltedOrbPrice;
MiscT2BreakPoint = MiscT2Base + MiscExaltedOrbInfluence * T2ExaltedInfluence * ExaltedOrbPrice;
MiscT3BreakPoint = MiscT3Base + MiscExaltedOrbInfluence * T3ExaltedInfluence * ExaltedOrbPrice;
MiscT4BreakPoint = MiscT4Base + MiscExaltedOrbInfluence * T4ExaltedInfluence * ExaltedOrbPrice;
// InfluenceGroups
InfluenceGroupT1BreakPoint = InfluenceGroupT1Base + InfluenceGroupExaltedOrbInfluence * T1ExaltedInfluence * ExaltedOrbPrice;
InfluenceGroupT2BreakPoint = InfluenceGroupT2Base + InfluenceGroupExaltedOrbInfluence * T2ExaltedInfluence * ExaltedOrbPrice;
LoggingFacade.LogInfo($"Prices Adjusted based on exalted orb price!");
}
private async Task WriteSeedFilter(Filter baseFilter, string filePath)
{
LoggingFacade.LogInfo("Writing SeedFilter!");
var seedFilterString = baseFilter.Serialize();
await FileWork.WriteTextAsync(filePath, seedFilterString);
LoggingFacade.LogInfo("DONE: Writing SeedFilter!");
}
public void Init(FileRequestResult dataRes)
{
if (dataRes != FileRequestResult.Success)
{
PublishPrice = false;
}
var filterOutFolder = Path.GetTempPath() + "filterGenerationResult";
var repoFolder = filterOutFolder + "\\" + RepoName;
this.RepoFolder = repoFolder;
LoggingFacade.LogInfo($"Tempfolder prepared");
if (!Directory.Exists(filterOutFolder))
{
Directory.CreateDirectory(filterOutFolder);
}
// clone/pull the repo. after that, we will edit these existing files by generating the new versions
// and push the update as the actual small changes.
if (Directory.Exists(repoFolder))
{
LoggingFacade.LogInfo($"Repo folder existing... renewing");
DeleteDirectory(repoFolder);
// RunCommand(filterOutFolder, "git", "branch --set-upstream-to=origin/master master");
// using (var repo = new Repository(repoFolder))
// {
// var options = new PullOptions();
// var author = Environment.GetEnvironmentVariable("author", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
// var email = Environment.GetEnvironmentVariable("email", EnvironmentVariableTarget.Process) ?? "FilterPolishZ";
// Commands.Pull(repo, new Signature(author, email, DateTimeOffset.Now), options);
// LoggingFacade.LogInfo($"Pulling done");
// }
}
{
LoggingFacade.LogInfo($"Repo folder not existing... cloning");
Repository.Clone("https://github.com/NeverSinkDev/" + RepoName + ".git", repoFolder);
LoggingFacade.LogInfo($"Cloning done!");
}
// create filter
LoggingFacade.LogInfo($"Performing filter generation operations");
var filterWriter = FilterWriter.WriteFilter(this.Filter, true, repoFolder + "\\", Path.GetDirectoryName(MainGenerationRoutine.DataFiles.FilterStyleFilesPaths.First().Value) + "\\");
filterWriter.Wait();
LoggingFacade.LogInfo($"Performing filter generation operations: DONE");
LoggingFacade.LogInfo($"Repofolder is: {RepoFolder}");
}
private void CreateZipFiles(object sender, RoutedEventArgs e)
{
using (var zipFileStream = new FileStream(Configuration.AppSettings["Output Folder"] + "RESULTS.zip", FileMode.OpenOrCreate))
{
using (var zipArch = new ZipArchive(zipFileStream, ZipArchiveMode.Create))
{
zipArch.ZipDirectory(Configuration.AppSettings["Output Folder"],
x => (x.Contains(".filter") && !x.ToLower().Contains("unnamed") && !x.ToLower().Contains("copy") && !x.ToLower().Contains("seed")),
x => (x.Contains("STYLE") || x.Contains("Console")));
}
}
Process.Start(Configuration.AppSettings["Output Folder"]);
LoggingFacade.LogInfo("Succesfully Archived Files!");
}
// TODO: Refactor
public void Enrich(string baseType, ItemList <NinjaItem> data)
{
if (baseType == "Exalted Orb")
{
var cPrice = data.Where(x => x.Name == "Exalted Orb")?.FirstOrDefault()?.CVal;
if (cPrice != null && cPrice > 30)
{
FilterPolishUtil.FilterPolishConfig.ExaltedOrbPrice = cPrice.Value;
LoggingFacade.LogInfo($"Exalted Price: {cPrice.Value}");
}
}
return;
}
private void ApplyAllSuggestions(object sender, RoutedEventArgs e)
{
this.TierListFacade.ApplyAllSuggestions();
this.TierListFacade.TierListData.Values.ToList().ForEach(x => x.ReEvaluate());
LoggingFacade.LogInfo($"Writing Changelog! Tiers Logged: {this.TierListFacade.Changelog.Select(x => x.Value.Count).Sum()}");
var json = JsonConvert.SerializeObject(this.TierListFacade.Changelog).Replace("->", "_");
var changeLogPath = LocalConfiguration.GetInstance().AppSettings["Output Folder"] + "/Changelog/changelog.json";
FileWork.WriteTextAsync(changeLogPath, json);
this.EventGrid.Publish();
}
private void LoadMetaFilter(object sender, RoutedEventArgs e)
{
var outputFolder = Configuration.AppSettings["Meta Filter Path"];
LoggingFacade.LogInfo($"Loading Meta Filter: {outputFolder}");
this.FilterExoFacade.RawMetaFilterText = FileWork.ReadLinesFromFile(outputFolder);
var output = this.FilterExoFacade.Execute();
GenerationOptions.TextSources = output;
EventGrid.Publish();
if (this.FilterRawString == null || this.FilterRawString.Count < 4500)
{
LoggingFacade.LogWarning($"Loading Filter: Meta-Filter Content Suspiciously Short");
}
}
public void CreateSubEconomyTiers()
{
LoggingFacade.LogInfo($"Generating Sub-Economy Tiers");
List <string> influenceTypes = new List <string>()
{
"Shaper", "Elder", "Warlord", "Crusader", "Redeemer", "Hunter"
};
var metaDictionary = new Dictionary <string, Dictionary <string, ItemList <NinjaItem> > >();
var otherbases = new Dictionary <string, ItemList <FilterEconomy.Model.NinjaItem> >();
influenceTypes.ForEach(x => metaDictionary.Add(x, new Dictionary <string, ItemList <NinjaItem> >()));
foreach (var items in this.EconomyTierlistOverview["basetypes"])
{
foreach (var influence in influenceTypes)
{
var influencedGroup = items.Value.Where(x => x.Variant == influence).ToList();
if (influencedGroup.Count != 0)
{
metaDictionary[influence].Add(items.Key, new ItemList <NinjaItem>());
metaDictionary[influence][items.Key].AddRange((influencedGroup));
}
}
var othergroup = items.Value.Where(x => !influenceTypes.Contains(x.Variant)).ToList();
if (othergroup.Count != 0)
{
otherbases.Add(items.Key, new ItemList <NinjaItem>());
otherbases[items.Key].AddRange((othergroup));
}
}
this.AddToDictionary("rare->shaper", metaDictionary["Shaper"]);
this.AddToDictionary("rare->elder", metaDictionary["Elder"]);
this.AddToDictionary("rare->warlord", metaDictionary["Warlord"]);
this.AddToDictionary("rare->crusader", metaDictionary["Crusader"]);
this.AddToDictionary("rare->redeemer", metaDictionary["Redeemer"]);
this.AddToDictionary("rare->hunter", metaDictionary["Hunter"]);
this.AddToDictionary("generalcrafting", otherbases);
LoggingFacade.LogInfo($"Done Generating Sub-Economy Tiers");
}
private void LoadAllComponents()
{
// request ninja-economy info
this.EconomyData = this.LoadEconomyOverviewData();
this.EconomyData.RequestPoeLeagueInfo();
if (Configuration.AppSettings["testLeague"] == "true" && !this.EconomyData.IsLeagueActive())
{
LoggingFacade.LogWarning("No Active League detected!");
}
// load aspects
this.ItemInfoData = this.LoadItemInformationOverview();
// load filter tierlists
this.TierListFacade = this.LoadTierLists(this.FilterAccessFacade.PrimaryFilter);
// add derived tiers (Shaper, Elder)
this.EconomyData.CreateSubEconomyTiers();
BaseTypeDataProvider.Initialize();
// run all the enrichment procedures (calculate confidence, min price, max price etc)
this.EconomyData.EnrichAll(EnrichmentProcedureConfiguration.PriorityEnrichmentProcedures);
FilterPolishUtil.FilterPolishConfig.AdjustPricingInformation();
this.EconomyData.EnrichAll(EnrichmentProcedureConfiguration.EnrichmentProcedures);
// experimental basetype->class abstraction
var abstractions = new InfluencedBasesAbstractionOverview();
abstractions.Execute();
var abstractionConclusons = new InfluencedBasesAbstractionConclusions();
abstractionConclusons.Execute();
// run tiering
this.TierListFacade.TierListData.Values.ToList().ForEach(x => x.ReEvaluate());
// Disable if CRASHY
this.InitializeMatrixFacade();
LoggingFacade.LogInfo($"FilterBlade main subroutine loaded succesfully");
}
private void CopyResultFilesToFilterFolder(object sender, RoutedEventArgs e)
{
var poeFolder = "%userprofile%/Documents/My Games/Path of Exile";
poeFolder = Environment.ExpandEnvironmentVariables(poeFolder);
LoggingFacade.LogInfo($"Copying filter files from: {poeFolder}");
LoggingFacade.LogInfo($"Copying filter files to: {Configuration.AppSettings["Output Folder"]}");
foreach (var file in System.IO.Directory.EnumerateFiles(Configuration.AppSettings["Output Folder"]))
{
if (!file.EndsWith(".filter"))
{
continue;
}
var targetPath = poeFolder + "\\" + file.Split('/', '\\').Last();
System.IO.File.Copy(file, targetPath, true);
}
}
public void ApplyAllSuggestions()
{
LoggingFacade.LogInfo("Applying All Suggestions!");
this.Changelog.Clear();
foreach (var section in this.Suggestions)
{
if (!this.TierListData.ContainsKey(section.Key) || (this.TierListData[section.Key].FilterEntries?.Count == 0))
{
if (FilterPolishConfig.MatrixTiersStrategies.Keys.Contains(section.Key))
{
continue;
}
LoggingFacade.LogWarning($"Skipping section {section.Key} . No data found for section!");
continue;
}
if (this.EnabledSuggestions.ContainsKey(section.Key) && !this.EnabledSuggestions[section.Key])
{
LoggingFacade.LogInfo($"SKIP Suggestions generation for: {section.Key}");
continue;
}
this.Changelog.Add(section.Key, new List <TieringChange>());
this.ApplyAllSuggestionsInSection(section.Key);
}
var keys = this.Changelog.Keys.ToList();
foreach (var section in keys)
{
this.Changelog[section] = this.Changelog[section].OrderBy(x => x.BaseType).ToList();
}
if (this.generatePrimitiveReport)
{
var report = this.GeneratePrimitiveReport();
var seedPath = this.WriteFolder + "tierlistchanges\\" + DateTime.Today.ToString().Replace("/", "-").Replace(":", "") + ".txt";
FileWork.WriteTextAsync(seedPath, report);
}
}
public void RequestPoeLeagueInfo()
{
this.PoeLeagues.Clear();
string responseString;
// Obtaining League Info
try
{
responseString = new RestRequest("http://api.pathofexile.com/leagues").Execute();
}
catch (Exception)
{
LoggingFacade.LogError($"Error obtaining League Information! PoE Api unresponsive?");
responseString = null;
}
List <PoeLeague> filteredLeagues;
try
{
var leagues = JsonConvert.DeserializeObject <IEnumerable <PoeLeague> >(responseString, new JsonSerializerSettings()
{
CheckAdditionalContent = true
});
filteredLeagues = leagues
.Where(x => !x.Id.Contains("Standard"))
.Where(x => !x.Id.Contains("SSF"))
.Where(x => !x.Id.Contains("Event"))
.Where(x => !x.Id.Contains("Race"))
.Where(x => x.Id != "Hardcore")
.ToList();
filteredLeagues.ForEach(x => this.PoeLeagues.Add(x.Id, x));
filteredLeagues.ForEach(x => LoggingFacade.LogInfo($"League Detected: {x.Id}"));
}
catch (Exception)
{
LoggingFacade.LogError($"Error deserializing or filtering league data!");
responseString = null;
}
}
// TODO: Refactor
public void Enrich(string baseType, ItemList <NinjaItem> data)
{
if (baseType == "Exalted Orb")
{
var cPrice = data.Where(x => x.Name == "Exalted Orb")?.FirstOrDefault()?.CVal;
if (EconomyRequestFacade.GetInstance().IsEarlyLeague() && cPrice > 75)
{
cPrice = 75;
}
if (cPrice != null && cPrice > 30)
{
FilterPolishUtil.FilterPolishConfig.ExaltedOrbPrice = cPrice.Value;
LoggingFacade.LogInfo($"Exalted Price: {cPrice.Value}");
}
}
return;
}
public void EnrichAll(Dictionary <string, List <IDataEnrichment> > enrichments)
{
LoggingFacade.LogInfo($"Starting Enriching Economy Information");
// for every section (divination card etc)
foreach (var section in this.EconomyTierlistOverview)
{
LoggingFacade.LogDebug($"Enriching Economy Information: {section.Key}");
// go through every item
foreach (var item in section.Value)
{
if (!enrichments.ContainsKey(section.Key))
{
continue;
}
enrichments[section.Key].ForEach(z => z.Enrich(item.Key, item.Value));
}
}
LoggingFacade.LogInfo($"Done Enriching Economy Information");
}
public FileRequestResult GetAllFiles(string league, string leagueType)
{
LoggingFacade.LogInfo($"Starting file request");
this.LeagueType = leagueType;
// Lade Filter Datei -> NS main github -> selective file(s?)
// Lade Style Dateien -> NS main github -> selective files
// Lade Aspect Dateien -> https://github.com/NeverSinkDev/Filter-ItemEconomyAspects -> ALL
LoggingFacade.LogInfo($"GitHub file download... starting");
this.LoadGitHubFiles();
LoggingFacade.LogInfo($"GitHub file download... done");
// Lade BaseType Datei -> FB
LoggingFacade.LogInfo($"BaseType Data Request: done");
this.BaseTypeData = FilterCore.Constants.BaseTypeDataProvider.BaseTypeData;
// Lade Economy Dateien -> ninja API
var ecoRes = this.LoadEcoData(league, leagueType);
LoggingFacade.LogInfo($"Ninja Eco Request Done: done");
if (ecoRes == FileRequestResult.Fail)
{
LoggingFacade.LogInfo($"Ninja Eco Request Done: failed");
return(ecoRes);
}
var itemData = ItemInformationFacade.GetInstance();
var economyData = EconomyRequestFacade.GetInstance();
foreach (var branchKey in economyData.EconomyTierlistOverview.Keys)
{
itemData.Deserialize(branchKey, String.Join(Environment.NewLine, this.ItemAspects[branchKey.Replace("->", "")]));
itemData.MigrateAspectDataToEcoData(economyData, branchKey);
}
return(ecoRes);
}
private TierListFacade LoadTierLists(Filter filter)
{
LoggingFacade.LogInfo($"Loading Tierlists...");
TierListFacade tierList = TierListFacade.GetInstance();
tierList.WriteFolder = Configuration.AppSettings["EcoFile Folder"];
var workTiers = FilterPolishConfig.FilterTierLists;
var tiers = filter.ExtractTiers(workTiers);
tierList.TierListData = tiers;
foreach (var item in tierList.TierListData.Values)
{
LoggingFacade.LogDebug($"Loading Tierlist: {item.Category}");
item.ReEvaluate();
}
LoggingFacade.LogInfo($"Done Loading Tierlists...");
return(tierList);
}
private void CopyResultsToGitHubFolder(object sender, RoutedEventArgs e)
{
var gitFolder = Configuration.AppSettings["Git Folder"];
LoggingFacade.LogInfo($"Copying filter files to: {gitFolder}");
foreach (var file in System.IO.Directory.EnumerateFiles(Configuration.AppSettings["Output Folder"], "*", SearchOption.AllDirectories))
{
var valid = false;
if (file.EndsWith(".filter") || file.EndsWith(".json") || file.EndsWith(".fsty"))
{
valid = true;
}
if (file.ToLower().Contains("unnamed") || file.ToLower().Contains("copy"))
{
continue;
}
if (!valid)
{
continue;
}
var targetPath = gitFolder + file.SkipSegment(Configuration.AppSettings["Output Folder"]);
if (!Directory.Exists(System.IO.Path.GetDirectoryName(targetPath)))
{
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(targetPath));
}
System.IO.File.Copy(file, targetPath, true);
}
LoggingFacade.LogInfo($"Done Copying filter files to: {Configuration.AppSettings["Git Folder"]}");
Process.Start(Configuration.AppSettings["Git Folder"]);
}
private EconomyRequestFacade LoadEconomyOverviewData()
{
LoggingFacade.LogDebug("Loading Economy Data...");
var result = EconomyRequestFacade.GetInstance();
var seedFolder = Configuration.AppSettings["EcoFile Folder"];
var variation = Configuration.AppSettings["leagueType"];
var league = Configuration.AppSettings["currentLeague"];
foreach (var tuple in FilterPolishConfig.FileRequestData)
{
PerformEcoRequest(tuple.Item1, tuple.Item2, tuple.Item3);
LoggingFacade.LogDebug($"Loading Economy: {tuple.Item1} + {tuple.Item2} + {tuple.Item3}");
}
void PerformEcoRequest(string dictionaryKey, string requestKey, string url) =>
result.AddToDictionary(dictionaryKey,
result.PerformRequest(league, variation, requestKey, url, seedFolder));
LoggingFacade.LogInfo("Economy Data Loaded...");
return(result);
}
public void Execute()
{
InfluencedItemInformation = null;
LoggingFacade.LogInfo($"Performing Influenced Class Abstractions");
List <KeyValuePair <float, string> > sortedConfList = new List <KeyValuePair <float, string> >();
List <KeyValuePair <float, string> > sortedPriceList = new List <KeyValuePair <float, string> >();
List <KeyValuePair <float, string> > sortedFullPriceList = new List <KeyValuePair <float, string> >();
var abstractionList = new InfluenceBTA();
foreach (var section in EconomyRequestFacade.GetInstance().EconomyTierlistOverview)
{
if (!section.Key.Contains("rare"))
{
continue;
}
var currentSection = abstractionList.AddNewSection(section.Key);
foreach (var item in section.Value)
{
if (BaseTypeDataProvider.BaseTypeData.ContainsKey(item.Key))
{
var currentBaseType = new BaseBTA();
currentBaseType.Name = item.Key;
for (int ilvl = 80; ilvl <= 86; ilvl++)
{
BaseBTA.ItemLevelContext = ilvl;
// Atlas bases falsify the results, so we're skipping them.
if (FilterPolishConfig.SpecialBases.Contains(item.Key))
{
currentBaseType.SpecialBase = true;
}
// We need to access the facade to augment eco information with basetypedata
var itemInfo = BaseTypeDataProvider.BaseTypeData[item.Key];
var dropLevel = int.Parse(itemInfo["DropLevel"]);
var itemClass = itemInfo["Class"].ToLower();
// New section treatment
if (!currentSection.Classes.ContainsKey(itemClass))
{
currentSection.AddNewClass(itemClass);
}
currentSection[itemClass][item.Key] = currentBaseType;
currentBaseType.EnterPrice(ilvl, item.Value, itemClass);
}
}
}
// Sort each list and omit the outliers
var filteredValueList = new Dictionary <string, List <float> >();
var filteredFullValueList = new Dictionary <string, List <float> >();
for (int ilvl = 80; ilvl <= 86; ilvl++)
{
BaseBTA.ItemLevelContext = ilvl;
foreach (var item in currentSection.Classes)
{
item.Value.CreateList();
var confPrice = item.Value.BaseTypesList
.Where(x => !x.SpecialBase).Average(x => x.ConfValueList.Count == 0 ? 0 : x.ConfValueList[ilvl]);
var fullPrice = item.Value.BaseTypesList
.Where(x => !x.SpecialBase).Average(x => x.FullValueList[ilvl]);
var validPrices = item.Value.BaseTypesList.Count(x => x.ConfValueList[ilvl] > 0.5f);
item.Value.AvgConfidence = item.Value.BaseTypes.Average(x => x.Value.Confidence);
item.Value.ConfPrices.Add(ilvl, confPrice);
item.Value.FullPrices.Add(ilvl, fullPrice);
item.Value.ValidItems.Add(ilvl, validPrices);
if (ilvl == 86)
{
sortedPriceList.Add(new KeyValuePair <float, string>(confPrice, $"[{ilvl}]{section.Key} >> {item.Key} >> { confPrice } { fullPrice } VALID: { validPrices }/{ item.Value.BaseTypes.Count }"));
}
}
}
}
var sortedValueList1 = sortedPriceList.OrderBy(x => x.Key).ToList();
foreach (var item in sortedValueList1)
{
LoggingFacade.LogDebug(item.Value);
}
InfluencedItemInformation = abstractionList;
}
public void PublishToLadder()
{
LoggingFacade.LogInfo($"PoeUpload: starting");
UploadToPoe(RepoFolder);
LoggingFacade.LogInfo($"PoeUpload: done");
}
public Dictionary <string, ItemList <FilterEconomy.Model.NinjaItem> > PerformRequest(string league, string leagueType, string branchKey, string url, string baseStoragePath)
{
var economySegmentBranch = url;
var directoryPath = $"{baseStoragePath}/{leagueType}/{league}/{StringWork.GetDateString()}";
var fileName = $"{branchKey}.txt";
var fileFullPath = $"{directoryPath}/{fileName}";
string responseString;
try
{
if (FilterPolishConfig.ActiveRequestMode != RequestType.ForceOnline && File.Exists(fileFullPath))
{ // Load existing file
LoggingFacade.LogInfo($"Loading Economy: Loading Cached File {fileFullPath}");
responseString = FileWork.ReadFromFile(fileFullPath);
}
else
{ // Request online file
string variation = this.CreateNinjaLeagueParameter(league, leagueType);
var urlRequest = $"{economySegmentBranch}&league={variation}";
try
{
responseString = new RestRequest(urlRequest).Execute();
}
catch (Exception)
{
LoggingFacade.LogError($"Loading Economy: Requesting From Ninja {urlRequest}");
responseString = null;
}
// poeNinja down -> use most recent local file
if ((responseString == null || responseString.Length < 400) && FilterPolishConfig.ActiveRequestMode == RequestType.Dynamic)
{
var recentFile = Directory
.EnumerateDirectories(directoryPath.Replace(StringWork.GetDateString(), ""))
.Where(x => File.Exists(x + "/" + fileName))
.OrderByDescending(Directory.GetCreationTime)
.FirstOrDefault();
if (recentFile != null && File.Exists(recentFile + "/" + fileName))
{
responseString = FileWork.ReadFromFile(recentFile + "/" + fileName);
if (responseString != null && responseString.Length >= 400)
{
if (!didShowNinjaOfflineMessage)
{
LoggingFacade.LogWarning("Could not connect to poeNinja. used recent local file instead: " + recentFile + "/" + fileName);
this.didShowNinjaOfflineMessage = true;
}
}
}
else
{
throw new Exception("did not find any old ninja files");
}
}
if (!string.IsNullOrEmpty(responseString) && FilterPolishConfig.ActiveRequestMode == RequestType.Dynamic)
{
// Store locally
FileWork.WriteText(fileFullPath, responseString);
}
}
if (responseString == null || responseString.Length < 400)
{
LoggingFacade.LogError("poeNinja web request or file content is null/short:\n\n\n" + responseString);
throw new Exception("poeNinja web request or file content is null/short:\n\n\n" + responseString);
}
}
catch (Exception e)
{
LoggingFacade.LogError("Failed to load economy file: " + branchKey + ": " + e);
return(null);
}
var result = NinjaParser.CreateOverviewDictionary(NinjaParser.ParseNinjaString(responseString, branchKey).ToList());
return(result);
}
public static void PerformMainRoutine(string req)
{
// 0) Cleanup
EconomyData?.Clean();
ItemInfoData?.Clean();
TierListFacade?.Clean();
FilterAccessFacade?.Clean();
BaseTypeDataProvider.Initialize();
EconomyData = EconomyRequestFacade.GetInstance();
TierListFacade = TierListFacade.GetInstance();
FilterAccessFacade = FilterAccessFacade.GetInstance();
ItemInfoData = ItemInformationFacade.GetInstance();
// 0) Get Current League information etc
EconomyData.RequestPoeLeagueInfo();
if (!EconomyData.IsLeagueActive())
{
LoggingFacade.LogWarning("No Active League detected!");
}
var requestedLeagueName = EconomyData.GetActiveLeagueName();
// 1) Acquire Data
var localMode = Environment.GetEnvironmentVariable("localMode", EnvironmentVariableTarget.Process) ?? "true";
// string body = new StreamReader(req.Body).ReadToEnd();
// var repoName = GetReqParams(req, data, "repoName", "NeverSink-EconomyUpdated-Filter");
// var leagueType = GetReqParams(req, data.leagueType, "leagueType", "tmpstandard");
dynamic data = JsonConvert.DeserializeObject(req);
string leagueType = data.leagueType ?? "tmpstandard";
string repoName = data.repoName ?? "NeverSink-EconomyUpdated-Filter";
string league = requestedLeagueName; //GetReqParams(req, data, "currentLeague", "Metamorph");
LoggingFacade.LogInfo($"[CONFIG] leagueType: {leagueType}");
LoggingFacade.LogInfo($"[CONFIG] league: {league}");
LoggingFacade.LogInfo($"[CONFIG] repoName: {repoName}");
LoggingFacade.LogInfo($"[CONFIG] localMode: {localMode}");
FilterPolishConfig.ApplicationExecutionMode = ExecutionMode.Function;
if (localMode == "true")
{
FilterPolishConfig.ActiveRequestMode = RequestType.Dynamic;
}
else
{
FilterPolishConfig.ActiveRequestMode = RequestType.ForceOnline;
}
DataFiles = new DataFileRequestFacade();
LoggingFacade.LogInfo($"[CONFIG] FileRequestFacade Created!");
FileRequestResult dataRes = DataFiles.GetAllFiles(league, leagueType);
// 3) Parse filter
FilterAccessFacade.PrimaryFilter = new Filter(DataFiles.SeedFilter);
var newVersion = FilterAccessFacade.PrimaryFilter.GetHeaderMetaData("VERSION") + "." + DateTime.Now.Year + "." + DateTime.Now.DayOfYear + "." + DateTime.Now.Hour;
FilterAccessFacade.PrimaryFilter.SetHeaderMetaData("VERSION", newVersion);
LoggingFacade.LogInfo($"[CONFIG] version: {newVersion}");
LoggingFacade.LogInfo($"[DEBUG] FileRequestResult: {dataRes.ToString()}");
LoggingFacade.LogInfo($"[DEBUG] League Active: {EconomyData.IsLeagueActive().ToString()}");
// null check the ecoData in case of disabled/early leagues
if (dataRes == FileRequestResult.Success)
{
// 4) Load tier list information and enrichment procedures
var tiers = FilterAccessFacade.PrimaryFilter.ExtractTiers(FilterPolishConfig.FilterTierLists);
TierListFacade.TierListData = tiers;
EconomyData.CreateSubEconomyTiers();
ConcreteEnrichmentProcedures.Initialize();
EconomyData.EnrichAll(EnrichmentProcedureConfiguration.PriorityEnrichmentProcedures);
FilterPolishUtil.FilterPolishConfig.AdjustPricingInformation();
EconomyData.EnrichAll(EnrichmentProcedureConfiguration.EnrichmentProcedures);
// EconomyData.PerformClassAbstractionProcedures();
TierListFacade.TierListData.Values.ToList().ForEach(x => x.ReEvaluate());
// 5) Generate Suggestions
var economyTieringSystem = new ConcreteEconomyRules();
economyTieringSystem.GenerateSuggestions();
// 6) Apply suggestions
TierListFacade.ApplyAllSuggestions();
}
// 7) Generate changelogs
// todo
LoggingFacade.LogInfo($"[DEBUG] Seedfiler regeneration done. Starting publishing...");
// 8) Generate and Upload Filters
new FilterPublisher(FilterAccessFacade.PrimaryFilter, repoName, leagueType).Run(dataRes);
}
public void PublishToFilterBladeBETA()
{
LoggingFacade.LogInfo($"Publishing to filterblade: starting");
PushToFTP("beta", RepoFolder, "NeverSink_AutoEcoUpdate_" + MainGenerationRoutine.DataFiles.LeagueType);
LoggingFacade.LogInfo($"Publishing to filterblade: done");
}
public void PublishToGitHub()
{
LoggingFacade.LogInfo($"GitUpdate: starting");
PushToGit(this.RepoFolder, PublishPrice);
LoggingFacade.LogInfo($"GitUpdate: done");
}
public static async Task WriteFilter(Filter baseFilter, bool isGeneratingStylesAndSeed, string outputFolder, string styleSheetFolderPath)
{
var isStopping = VerifyFilter(baseFilter);
if (isStopping)
{
return;
}
new FilterTableOfContentsCreator(baseFilter).Run();
const string filterName = "NeverSink's";
var generationTasks = new List <Task>();
var seedFilterString = baseFilter.Serialize();
if (isGeneratingStylesAndSeed)
{
var seedPath = outputFolder + "ADDITIONAL-FILES\\SeedFilter\\";
if (!Directory.Exists(seedPath))
{
Directory.CreateDirectory(seedPath);
}
seedPath += filterName + " filter - SEED (SeedFilter) .filter";
generationTasks.Add(FileWork.WriteTextAsync(seedPath, seedFilterString));
}
baseFilter = new Filter(seedFilterString); // we do not want to edit the seedFilter directly and execute its tag commands
baseFilter.ExecuteCommandTags();
var baseFilterString = baseFilter.Serialize();
if (baseFilterString == null || baseFilterString.Count < 4500)
{
LoggingFacade.LogError("Warning: (seed) filter result line count: " + baseFilterString?.Count);
}
for (var strictnessIndex = 0; strictnessIndex < FilterGenerationConfig.FilterStrictnessLevels.Count; strictnessIndex++)
{
if (isGeneratingStylesAndSeed)
{
foreach (var style in FilterGenerationConfig.FilterStyles)
{
if (style.ToLower() == "default" || style.ToLower() == "backup" || style.ToLower() == "streamsound")
{
continue;
}
generationTasks.Add(GenerateFilter_Inner(style, strictnessIndex));
}
}
// default style
generationTasks.Add(GenerateFilter_Inner("", strictnessIndex));
}
if (isGeneratingStylesAndSeed)
{
generationTasks.Add(GenerateFilter_Inner("", 3, 2, explicitName: "NeverSink's filter - 1X-ConStrict"));
generationTasks.Add(GenerateFilter_Inner("", 4, 2, explicitName: "NeverSink's filter - 2X-ConStrict"));
generationTasks.Add(GenerateFilter_Inner("", 4, 3, explicitName: "NeverSink's filter - 3X-ConStrict"));
generationTasks.Add(GenerateFilter_Inner("", 5, 3, explicitName: "NeverSink's filter - 4X-ConStrict"));
generationTasks.Add(GenerateFilter_Inner("", 6, 3, explicitName: "NeverSink's filter - 5X-ConStrict"));
}
await Task.WhenAll(generationTasks);
LoggingFacade.LogInfo("Filter generation successfully done!", true);
// local func
async Task GenerateFilter_Inner(string style, int strictnessIndex, int?consoleStrictness = null, string explicitName = null)
{
var filePath = outputFolder;
var fileName = filterName + " filter - " + strictnessIndex + "-" + FilterGenerationConfig.FilterStrictnessLevels[strictnessIndex].ToUpper();
var filter = new Filter(baseFilterString);
LoggingFacade.LogDebug($"GENERATING: {fileName}");
new FilterTableOfContentsCreator(filter).Run();
filter.ExecuteStrictnessCommands(strictnessIndex, consoleStrictness);
if (style != "")
{
new StyleGenerator(filter, styleSheetFolderPath + style + ".fsty", style).Apply();
filePath += "(STYLE) " + style.ToUpper() + "\\";
fileName += " (" + style + ") ";
}
if (consoleStrictness.HasValue)
{
// little dirty fix
filePath += "(Console-Strictness)\\";
fileName += " Console-Strictness ";
}
if (explicitName != null)
{
fileName = explicitName;
}
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
var result = filter.Serialize();
if (result.Count <= seedFilterString?.Count)
{
LoggingFacade.LogError("Error: style/strictness variant is smaller size than seed");
}
await FileWork.WriteTextAsync(filePath + "\\" + fileName + ".filter", result);
LoggingFacade.LogInfo($"DONE GENERATING: {fileName}");
}
}
/// <summary>
/// Generates suggestions, but doesn't apply them.
/// </summary>
public void GenerateSuggestions()
{
this.Rules.ForEach(x => x.GenerateAndAddSuggestions());
LoggingFacade.LogInfo("Done (Re)generating Tiering Suggestions");
}