public static async Task <Common.Http.Client> GetAuthorizedClient(string?apiKey = null)
{
var client = new Common.Http.Client();
client.Headers.Add(("X-API-KEY", await GetAPIKey(apiKey)));
return(client);
}
public static async Task <Common.Http.Client> GetClient()
{
var client = new Common.Http.Client();
client.Headers.Add((Consts.MetricsKeyHeader, await Metrics.GetMetricsKey()));
return(client);
}
public static async Task <List <ModlistMetadata> > LoadFromGithub()
{
var client = new Common.Http.Client();
Utils.Log("Loading ModLists from GitHub");
var metadataResult = client.GetStringAsync(Consts.ModlistMetadataURL);
var summaryResult = client.GetStringAsync(Consts.ModlistSummaryURL);
var metadata = (await metadataResult).FromJsonString <List <ModlistMetadata> >();
try
{
var summaries = (await summaryResult).FromJsonString <List <ModListSummary> >().ToDictionary(d => d.MachineURL);
foreach (var data in metadata)
{
if (summaries.TryGetValue(data.Links.MachineURL, out var summary))
{
data.ValidationSummary = summary;
}
}
}
catch (Exception)
{
// ignored
}
return(metadata.OrderBy(m => (m.ValidationSummary?.HasFailures ?? false ? 1 : 0, m.Title)).ToList());
}
public override async Task <bool> Verify(Archive archive)
{
var client = new Common.Http.Client();
var result = await client.GetAsync(Url, errorsAsExceptions : false);
return(result.IsSuccessStatusCode);
}
public override async Task <bool> Download(Archive a, AbsolutePath destination)
{
destination.Parent.CreateDirectory();
var definition = await GetDefinition();
await using var fs = await destination.Create();
using var mmfile = MemoryMappedFile.CreateFromFile(fs, null, definition.Size, MemoryMappedFileAccess.ReadWrite, HandleInheritability.None, false);
var client = new Common.Http.Client();
using var queue = new WorkQueue();
await definition.Parts.PMap(queue, async part =>
{
Utils.Status($"Downloading {a.Name}", Percent.FactoryPutInRange(definition.Parts.Length - part.Index, definition.Parts.Length));
await using var ostream = mmfile.CreateViewStream(part.Offset, part.Size);
using var response = await client.GetAsync($"{Url}/parts/{part.Index}");
if (!response.IsSuccessStatusCode)
{
throw new HttpException((int)response.StatusCode, response.ReasonPhrase);
}
await response.Content.CopyToAsync(ostream);
});
return(true);
}
private static async Task <IEnumerable <UpdateRecord> > GetFeed(Uri uri)
{
var client = new Common.Http.Client();
var data = await client.GetStringAsync(uri);
var reader = XmlReader.Create(new StringReader(data));
var results = SyndicationFeed.Load(reader);
return(results.Items
.Select(itm =>
{
if (TryParseGameUrl(itm.Links.First(), out var game, out var modId))
{
return new UpdateRecord
{
TimeStamp = itm.PublishDate.UtcDateTime,
Game = game,
ModId = modId
};
}
return null;
})
.NotNull());
}
public static Common.Http.Client GetClient(IEnumerable <Cookie> cookies, string referer)
{
var client = new Common.Http.Client();
client.Headers.Add(("Referrer", referer));
client.Cookies.AddRange(cookies.Select(cookie => new System.Net.Cookie(cookie.Name, cookie.Value, cookie.Path, cookie.Domain)));
return(client);
}
private async Task <CDNFileDefinition> GetDefinition()
{
var client = new Common.Http.Client();
using var data = await client.GetAsync(Url + "/definition.json.gz");
await using var gz = new GZipStream(await data.Content.ReadAsStreamAsync(), CompressionMode.Decompress);
return(gz.FromJson <CDNFileDefinition>());
}
private async Task <HTTPDownloader.State?> Resolve()
{
var client = new Common.Http.Client();
var body = await client.GetHtmlAsync(Url);
var node = body.DocumentNode.DescendantsAndSelf().First(d => d.HasClass("input") && d.HasClass("popsok") &&
d.GetAttributeValue("aria-label", "") == "Download file");
return(new HTTPDownloader.State(node.GetAttributeValue("href", "not-found")));
}
public static Common.Http.Client GetClient()
{
var client = new Common.Http.Client();
if (Utils.HaveEncryptedJson(Consts.MetricsKeyHeader))
{
client.Headers.Add((Consts.MetricsKeyHeader, Utils.FromEncryptedJson <string>(Consts.MetricsKeyHeader)));
}
return(client);
}
public async Task LoadListsFromGithub()
{
var client = new Common.Http.Client();
Utils.Log("Loading server whitelist");
using (var response = await client.GetAsync(Consts.ServerWhitelistURL))
using (var result = await response.Content.ReadAsStreamAsync())
{
ServerWhitelist = result.FromYaml <ServerWhitelist>();
Utils.Log($"Loaded permissions for {ServerWhitelist.AllowedPrefixes?.Count ?? 0} servers and {ServerWhitelist.GoogleIDs?.Count ?? 0} Google Drive files");
}
}
/// <summary>
/// Given an archive hash, search the Wabbajack server for a matching .ini file
/// </summary>
/// <param name="hash"></param>
/// <returns></returns>
public static async Task <string?> GetModIni(Hash hash)
{
var client = new Common.Http.Client();
try
{
return(await client.GetStringAsync(
$"{Consts.WabbajackBuildServerUri}indexed_files/{hash.ToHex()}/meta.ini"));
}
catch (HttpException)
{
return(null);
}
}
public override async Task <bool> Download(Archive a, AbsolutePath destination)
{
destination.Parent.CreateDirectory();
var definition = await GetDefinition();
await using var fs = destination.Create();
var client = new Common.Http.Client();
await definition.Parts.DoProgress($"Downloading {a.Name}", async part =>
{
fs.Position = part.Offset;
using var response = await client.GetAsync($"{Url}/parts/{part.Index}");
if (!response.IsSuccessStatusCode)
{
throw new HttpException((int)response.StatusCode, response.ReasonPhrase);
}
await response.Content.CopyToAsync(fs);
});
return(true);
}
private async Task <HTTPDownloader.State> ToHttpState()
{
var initialURL = $"https://drive.google.com/uc?id={Id}&export=download";
var client = new Common.Http.Client();
using var response = await client.GetAsync(initialURL);
if (!response.IsSuccessStatusCode)
{
throw new HttpException((int)response.StatusCode, response.ReasonPhrase);
}
var regex = new Regex("(?<=/uc\\?export=download&confirm=).*(?=;id=)");
var confirm = regex.Match(await response.Content.ReadAsStringAsync());
var url = $"https://drive.google.com/uc?export=download&confirm={confirm}&id={Id}";
var httpState = new HTTPDownloader.State(url)
{
Client = client
};
return(httpState);
}
public static async Task <bool> UploadPackagedInis(IEnumerable <Archive> archives)
{
archives = archives.ToArray(); // defensive copy
Utils.Log($"Packaging {archives.Count()} inis");
try
{
await using var ms = new MemoryStream();
using (var z = new ZipArchive(ms, ZipArchiveMode.Create, true))
{
foreach (var e in archives)
{
if (e.State == null)
{
continue;
}
var entry = z.CreateEntry(Path.GetFileName(e.Name));
await using var os = entry.Open();
await os.WriteAsync(Encoding.UTF8.GetBytes(string.Join("\n", e.State.GetMetaIni())));
}
}
var client = new Common.Http.Client();
var response = await client.PostAsync($"{Consts.WabbajackBuildServerUri}indexed_files/notify", new ByteArrayContent(ms.ToArray()));
if (response.IsSuccessStatusCode)
{
return(true);
}
Utils.Log("Error sending Inis");
Utils.Log(await response.Content.ReadAsStringAsync());
return(false);
}
catch (Exception ex)
{
Utils.Log(ex.ToString());
return(false);
}
}
public async Task Send(Channel channel, DiscordMessage message)
{
try
{
string url = channel switch
{
Channel.Spam => _settings.SpamWebHook,
Channel.Ham => _settings.HamWebHook,
_ => null
};
if (url == null)
{
return;
}
var client = new Common.Http.Client();
await client.PostAsync(url, new StringContent(message.ToJson(true), Encoding.UTF8, "application/json"));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.ToJson());
}
}
private async Task <(Common.Http.Client, CDPTree, CollectedBNetInfo)> ResolveDownloadInfo()
{
var info = new CollectedBNetInfo();
var login_info = await Utils.FromEncryptedJson <BethesdaNetData>(DataName);
var client = new Common.Http.Client();
client.Headers.Add(("User-Agent", "bnet"));
foreach (var header in login_info.headers.Where(h => h.Key.ToLower().StartsWith("x-")))
{
client.Headers.Add((header.Key, header.Value));
}
var posted = await client.PostAsync("https://api.bethesda.net/beam/accounts/external_login",
new StringContent(login_info.body, Encoding.UTF8, "application/json"));
info.AccessToken = (await posted.Content.ReadAsStringAsync()).FromJsonString <BeamLoginResponse>().access_token;
client.Headers.Add(("x-cdp-app", "UGC SDK"));
client.Headers.Add(("x-cdp-app-ver", "0.9.11314/debug"));
client.Headers.Add(("x-cdp-lib-ver", "0.9.11314/debug"));
client.Headers.Add(("x-cdp-platform", "Win/32"));
posted = await client.PostAsync("https://api.bethesda.net/cdp-user/auth",
new StringContent("{\"access_token\": \"" + info.AccessToken + "\"}", Encoding.UTF8,
"application/json"));
info.CDPToken = (await posted.Content.ReadAsStringAsync()).FromJsonString <CDPLoginResponse>().token;
client.Headers.Add(("X-Access-Token", info.AccessToken));
var got = await client.GetAsync($"https://api.bethesda.net/mods/ugc-workshop/content/get?content_id={ContentId}");
JObject data = JObject.Parse(await got.Content.ReadAsStringAsync());
var content = data["platform"] !["response"] !["content"] !;
public async Task DoesntReuseHttpMessages()
{
var client = new Common.Http.Client();
// If we reuse the HTTP message this will throw a invalid operation exception
await Assert.ThrowsAsync <HttpRequestException>(async() => await client.GetAsync("http://blerg.blaz.bloz.buz"));
}
public async Task Prepare()
{
AuthedClient = (await GetAuthedClient()) ?? throw new NotLoggedInError(this);
}
private Client(Common.Http.Client client)
{
_client = client;
}