public static async Task <List <ResolvedInfo> > GetNames(List <int> ids)
{
EnsureInit();
ids = ids.Distinct().ToList();
// Why does this method require longs, but return models with ints!!!?!?!?!??!
// TOOD: file an issue, or just patch it
List <long> intsToLongs = ids.Select(x => (long)x).ToList();
EsiResponse <List <ResolvedInfo> > response = await s_client.Universe.Names(intsToLongs);
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("[Error] Unable to query ESI for names. Status: {0} Error {1}", response.StatusCode, response.Message);
return(null); // Proper response for cannot resolve?
}
var infos = response.Data;
for (int i = 0; i < infos.Count; i++)
{
s_cachedNames.Add(infos[i].Id, infos[i]);
RedisHelper.Set <ResolvedInfo>(string.Format("esi:names:{0}", infos[i].Id), infos[i]);
}
return(infos);
}
public async Task GetAllianceIcon()
{
var stubbedData = new Icon
{
Url128 = "some/128px/url",
Url64 = "some/64px/url"
};
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <Icon>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <Icon>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var allianceEndpoint = new AllianceEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await allianceEndpoint.GetAllianceIcon(1);
Assert.AreEqual(response, result);
}
public static async Task <Constellation> GetConstellation(int id)
{
EnsureInit();
Constellation constellation;
if (s_cachedConstellations.TryGetValue(id, out constellation))
{
return(constellation);
}
constellation = RedisHelper.Get <Constellation>(string.Format("esi:constellations:{0}", id));
if (constellation != null)
{
return(constellation);
}
// Call ESI
EsiResponse <Constellation> response = await s_client.Universe.Constellation(id);
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("[Error] Unable to query ESI for constellation. Status: {0} Error {1}", response.StatusCode, response.Message);
return(null);
}
s_cachedConstellations[id] = response.Data;
RedisHelper.Set <Constellation>(string.Format("esi:constellation:{0}", id), response.Data);
return(response.Data);
}
public static async Task <SolarSystem> GetSystem(int id)
{
EnsureInit();
// TODO: I believe this can probably be simplified through some template magic
SolarSystem system;
if (s_cachedSystems.TryGetValue(id, out system))
{
return(system);
}
system = RedisHelper.Get <SolarSystem>(string.Format("esi:systems:{0}", id));
if (system != null)
{
return(system);
}
EsiResponse <SolarSystem> response = await s_client.Universe.System(id);
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("[Error] Unable to query ESI for systems. Status: {0} Error {1}", response.StatusCode, response.Message);
return(null);
}
s_cachedSystems[id] = response.Data;
RedisHelper.Set <SolarSystem>(string.Format("esi:systems:{0}", id), response.Data);
return(response.Data);
}
public void CreateResponseFromObject()
{
var stubbedData = new FakeType
{
SomeId = 42,
SomeData = "the meaning of life"
};
var response = new EsiResponse <FakeType>(HttpStatusCode.OK, stubbedData);
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var result = _responseFactory.Create <FakeType>(httpResponse);
if (!(result.Data is null))
{
Assert.AreEqual(response.Data !.SomeId, result.Data.SomeId);
Assert.AreEqual(response.Data !.SomeData, result.Data.SomeData);
Assert.IsNull(result.Error);
Assert.IsNull(result.Message);
}
/// <summary>
/// Invites the pilot to a fleet. If a specific squad is not specified they will be invited to the default squad.
/// </summary>
/// <param name="fleetBoss">Fleet Boss explicit cast as AuthorizedCharacterData</param>
/// <param name="fleetId">Target fleet Id</param>
/// <param name="squadId">Target squad Id</param>
/// <param name="pilotId">Invitee Id</param>
public static async Task <object> FleetInvite(AuthorizedCharacterData fleetBoss, long fleetId, long squadId, long wingId, int pilotId)
{
try
{
EsiClient x = GetEsiClient();
x.SetCharacterData(fleetBoss);
EsiResponse <string> response = await x.Fleets.InviteCharacter(fleetId, pilotId, ESI.NET.Enumerations.FleetRole.SquadMember, wingId, squadId);
if (response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error search API '{1}': {2}", response.StatusCode, response.Endpoint, response.Message);
Exception ex;
if (response.Message.Contains("'error_label': 'FleetCandidateOffline', 'error_dict'"))
{
ex = new Exception("Fleet Candidate Offline");
}
else
{
ex = new Exception(response.Message);
}
throw new Exception("Fleet Invite Failed", ex);
}
return(null);
}
catch (Exception ex)
{
//s_Log.LogError("{0} error searching API '{1}': {2}", FleetMembers_response.StatusCode, FleetMembers_response.Endpoint, FleetMembers_response.Message);
//throw new Exception(FleetLayout_response.ErrorType().ToString());
throw new NotImplementedException();
}
}
public async Task RespondToEventTest()
{
var httpResponse = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.NoContent
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <string>(HttpStatusCode.NoContent);
_mockDataService
.Setup(m => m.PutAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <string>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var calendarEndpoint = new CalendarEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await calendarEndpoint.RespondToEvent(
1,
1,
Enums.Calendar.EventResponses.Accepted);
Assert.IsTrue(result.Success);
Assert.AreEqual(HttpStatusCode.NoContent, result.StatusCode);
Assert.IsNull(result.Message);
Assert.IsNull(result.Data);
Assert.IsNull(result.Error);
}
public async Task GetAllianceCorporationIds()
{
var stubbedData = new int[100];
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <int[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <int[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var allianceEndpoint = new AllianceEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await allianceEndpoint.GetAllianceCorporationIds(1);
Assert.AreEqual(response, result);
}
public async Task GetBookmarkFolders()
{
var stubbedData = new [] {
new BookmarkFolder(1, "some_folder"),
new BookmarkFolder(2, "some_other_folder")
};
var httpResponse = new HttpResponseMessage()
{
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <BookmarkFolder[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <BookmarkFolder[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var bookmarksEndpoint = new BookmarksEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var characterResult = await bookmarksEndpoint.Characters.GetBookmarkFolders(1);
var corporationResult = await bookmarksEndpoint.Corporations.GetBookmarkFolders(2);
Assert.AreEqual(response, characterResult);
Assert.AreEqual(response, corporationResult);
}
public async Task Ping()
{
var data = "ok";
var httpResponse = new HttpResponseMessage
{
Content = new StringContent(JsonSerializer.Serialize(data))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <string>(HttpStatusCode.OK, "ok");
// Ensure that the call to Get returns our mocked response.
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <string>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
// Create our endpoint and call ping.
var metaEndpoint = new MetaEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await metaEndpoint.Ping();
// Assert that the outcome is what was expected.
Assert.AreEqual(response, result);
}
public static bool ValidateESICall <T>(EsiResponse <T> esiR)
{
if (esiR.StatusCode == HttpStatusCode.OK || esiR.StatusCode == HttpStatusCode.NoContent)
{
return(true);
}
Console.WriteLine("ESI Error : " + esiR.Message + " Error Limit Remaining : " + esiR.ErrorLimitRemain);
return(false);
}
public async Task GetAssets()
{
var stubbedData = new [] {
new Asset(
Enums.Locations.LocationFlags.Cargo.ToString(),
Enums.Locations.LocationTypes.Item.ToString())
{
IsBlueprintCopy = true,
IsSingleton = true,
ItemId = 1234567,
LocationId = 1234567,
Quantity = 42,
TypeId = 1234567
},
new Asset(
Enums.Locations.LocationFlags.Hangar.ToString(),
Enums.Locations.LocationTypes.Other.ToString())
{
IsBlueprintCopy = false,
IsSingleton = false,
ItemId = 12345678,
LocationId = 12345678,
Quantity = 84,
TypeId = 12345678
}
};
var httpResponse = new HttpResponseMessage()
{
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <Asset[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <Asset[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var assetsEndpoint = new AssetsEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
// These use the same underlying code so we might as well test them all.
var characterResult = await assetsEndpoint.Characters.GetAssets(1);
var corporationResult = await assetsEndpoint.Corporations.GetAssets(2);
Assert.AreEqual(response, characterResult);
Assert.AreEqual(response, corporationResult);
}
public async Task <IActionResult> Blueprints()
{
await Util.Esi.UpdateTokenAsync(await HttpContext.GetTokenAsync("refresh_token"), await userManager.GetUserAsync(User), esiClient);
EsiResponse <List <Blueprint> > esiResponse = await esiClient.Character.Blueprints(1);
if (esiResponse.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception("Failed to get result", esiResponse.Exception);
}
return(View(esiResponse.Data));
}
public static async Task <int[]> GetAllSystemIds()
{
EnsureInit();
EsiResponse <int[]> SystemsArray_response = await s_client.Universe.Systems();
if (SystemsArray_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error searching API '{1}': {2}", SystemsArray_response.StatusCode, SystemsArray_response.Endpoint, SystemsArray_response.Message);
return(null);
}
return(SystemsArray_response.Data);
}
public static async Task <SearchResults> Search(string searchTerm, bool strict, SearchCategory category)
{
EnsureInit();
EsiResponse <SearchResults> Search_response = await s_client.Search.Query(SearchType.Public, searchTerm, category, strict);
if (Search_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error searching API '{1}': {2}", Search_response.StatusCode, Search_response.Endpoint, Search_response.Message);
return(null);
}
return(Search_response.Data);
}
public static async Task <ESI.NET.Models.Universe.SolarSystem> GetSystemInformation(int SystemId)
{
EnsureInit();
EsiResponse <ESI.NET.Models.Universe.SolarSystem> SystemInfo_response = await s_client.Universe.System(SystemId);
if (SystemInfo_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error searching API '{1}': {2}", SystemInfo_response.StatusCode, SystemInfo_response.Endpoint, SystemInfo_response.Message);
return(null);
}
return(SystemInfo_response.Data);
}
/// <summary>
/// Temporary solution for now for the pages issue
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="myTask"></param>
/// <param name="pages"></param>
/// <returns></returns>
protected T DownloadData <T>(Task <EsiResponse <T> > myTask, out int?pages)
{
int?pagesResult = null;
Task <EsiResponse <T> > workingObject = myTask;
dynamic result = default(T);
if (workingObject.Status == TaskStatus.WaitingForActivation)
{
int waitCounter = 0;
while (workingObject.Status == TaskStatus.WaitingForActivation)
{
Task.Delay(100).Wait();
waitCounter++;
if (waitCounter > 150)
{
pages = 0;
return(default(T));
}
}
}
if (workingObject.IsFaulted)
{
// throw an error maybe?
}
else
{
if (workingObject.Status == TaskStatus.RanToCompletion)
{
EsiResponse <T> data = workingObject.Result;
pagesResult = data.Pages;
if (data.StatusCode != System.Net.HttpStatusCode.NotFound)
{
if (data.Data != null && data.Data.GetType() == typeof(int))
{
result = int.Parse(data.Message);
}
else if (data.Data != null && data.Data.GetType() == typeof(decimal))
{
result = decimal.Parse(data.Message);
}
else
{
result = data.Data;
}
}
}
}
pages = pagesResult;
return(result);
}
/// <summary>
/// Checks ESI to see if the pilot is online.
/// </summary>
/// <param name="pilot">Pilot explicit cast as AuthorizedCharacterData</param>
/// <returns>Bool</returns>
public static async Task <bool> IsOnlineAsync(AuthorizedCharacterData pilot)
{
EsiClient x = GetEsiClient();
x.SetCharacterData(pilot);
EsiResponse <ESI.NET.Models.Location.Activity> Location_response = await x.Location.Online();
if (Location_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error searching API '{1}': {2}", Location_response.StatusCode, Location_response.Endpoint, Location_response.Message);
return(true);
}
return(Location_response.Data.Online);
}
public static async Task <List <ESI.NET.Models.Fleets.Wing> > GetFleetLayout(AuthorizedCharacterData fleetBoss, long fleetId)
{
EsiClient x = GetEsiClient();
x.SetCharacterData(fleetBoss);
EsiResponse <List <ESI.NET.Models.Fleets.Wing> > FleetLayout_response = await x.Fleets.Wings(fleetId);
if (FleetLayout_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error search API '{1}': {2}", FleetLayout_response.StatusCode, FleetLayout_response.Endpoint, FleetLayout_response.Message);
throw new Exception(FleetLayout_response.ErrorType().ToString());
}
return(FleetLayout_response.Data);
}
public async Task <SystemInfo> SearchSystemName(string searchSystem)
{
EsiResponse <ESI.NET.Models.Universe.IDLookup> searchResults = await client.Universe.IDs(new List <string>() { searchSystem });
if (searchResults.Data.Systems.Count == 0)
{
return(null);
}
EsiResponse <ESI.NET.Models.Universe.SolarSystem> SystemData = await client.Universe.System(searchResults.Data.Systems[0].Id);
SystemInfo toReturn = new SystemInfo();
int moonCount = 0;
int beltCount = 0;
foreach (ESI.NET.Models.Universe.Planet temp in SystemData.Data.Planets)
{
if (temp.AsteroidBelts != null)
{
beltCount += temp.AsteroidBelts.Count();
}
if (temp.Moons != null)
{
moonCount += temp.Moons.Count();
}
}
toReturn.SystemID = SystemData.Data.SystemId;
toReturn.SystemName = SystemData.Data.Name;
toReturn.Planets = SystemData.Data.Planets.Count();
toReturn.Moons = moonCount;
toReturn.Belts = beltCount;
toReturn.secStatus = Decimal.Ceiling(SystemData.Data.SecurityStatus);
EsiResponse <List <ESI.NET.Models.Universe.Kills> > systemKills = await client.Universe.Kills();
foreach (var temp in systemKills.Data)
{
if (temp.SystemId == SystemData.Data.SystemId)
{
toReturn.Kills = temp.ShipKills + temp.PodKills;
toReturn.NPCKills = temp.NpcKills;
}
}
//systemKills.Data.Find()
return(toReturn);
}
public static async Task <ESI.NET.Models.Location.Location> GetSystem(AuthorizedCharacterData pilot)
{
EsiClient x = GetEsiClient();
x.SetCharacterData(pilot);
EsiResponse <ESI.NET.Models.Location.Location> Location_response = await x.Location.Location();
if (Location_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error searching API '{1}': {2}", Location_response.StatusCode, Location_response.Endpoint, Location_response.Message);
return(null);
}
return(Location_response.Data);
}
/// <summary>
/// Resolves a Type ID to a ship using ESI
/// </summary>
public static async Task <List <ESI.NET.Models.Universe.ResolvedInfo> > GetShipTypeAsync(int typeId)
{
EnsureInit();
List <long> ids = new List <long>
{
typeId
};
EsiResponse <List <ESI.NET.Models.Universe.ResolvedInfo> > resolvedInfo_response = await s_client.Universe.Names(ids);
if (resolvedInfo_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error resolving IDs to names'{1}': {2}", resolvedInfo_response.StatusCode, resolvedInfo_response.Endpoint, resolvedInfo_response.Message);
return(null);
}
return(resolvedInfo_response.Data);
}
public async Task GetAssetLocations()
{
var stubbedPosition = new Position(1, 2, 3);
var stubbedIds = new List <long> {
1, 2, 3, 4, 5
};
var stubbedData = new []
{
new AssetLocation(stubbedPosition)
{
ItemId = 1
},
new AssetLocation(stubbedPosition)
{
ItemId = 2
}
};
var httpResponse = new HttpResponseMessage()
{
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <AssetLocation[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.PostAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <AssetLocation[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var assetsEndpoint = new AssetsEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var characterResult = await assetsEndpoint.Characters.GetAssetLocations(1, stubbedIds);
var corporationResult = await assetsEndpoint.Corporations.GetAssetLocations(2, stubbedIds);
Assert.AreEqual(response, characterResult);
Assert.AreEqual(response, corporationResult);
}
public async Task GetEventAttendees()
{
var stubbedData = new []
{
new EventAttendee()
{
CharacterId = 1,
Response = Enums.Calendar.EventResponses.Accepted
},
new EventAttendee()
{
CharacterId = 2,
Response = Enums.Calendar.EventResponses.Declined
}
};
var httpResponse = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <EventAttendee[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <EventAttendee[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var calendarEndpoint = new CalendarEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await calendarEndpoint.GetEventAttendees(1, 1);
Assert.IsNull(result.Error);
Assert.IsNull(result.Message);
Assert.IsTrue(result.Success);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(stubbedData, result.Data);
}
public async Task GetEventSummaryTest()
{
var stubbedData = new EventSummary[]
{
new EventSummary()
{
Id = 1,
Title = "Fake Event",
EventDate = new DateTime(2021, 1, 31).ToString(),
Response = Enums.Calendar.EventResponses.Accepted,
Importance = 1
}
};
var httpResponse = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <EventSummary[]>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <EventSummary[]>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var calendarEndpoint = new CalendarEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await calendarEndpoint.GetEventSummaries(1);
Assert.IsTrue(result.Success);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.IsNotNull(result.Data);
Assert.IsNull(result.Error);
Assert.IsNull(result.Message);
Assert.AreEqual(stubbedData, result.Data);
}
public async Task GetEvent()
{
var stubbedData = new Event(
new DateTime(2021, 1, 31).ToString(),
5,
1,
1,
1,
"Some Owner",
Enums.Calendar.OwnerType.Character,
Enums.Calendar.EventResponses.Declined,
"Some text",
"Some Title");
var httpResponse = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(stubbedData))
};
var httpResponseTask = Task.FromResult(httpResponse);
var response = new EsiResponse <Event>(HttpStatusCode.OK, stubbedData);
_mockDataService
.Setup(m => m.GetAsync(It.IsAny <Url>()))
.Returns(httpResponseTask);
_mockResponseFactory
.Setup(m => m.Create <Event>(It.IsAny <HttpResponseMessage>()))
.Returns(response);
var calendarEndpoint = new CalendarEndpoint(
_mockDataService.Object,
_mockResponseFactory.Object);
var result = await calendarEndpoint.GetEvent(1, 1);
Assert.IsTrue(result.Success);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(stubbedData, result.Data);
Assert.IsNull(result.Error);
Assert.IsNull(result.Message);
}
public static async Task <List <Incursion> > GetIncursions()
{
EnsureInit();
if ((DateTime.UtcNow - s_lastIncursionPoll).TotalSeconds < IncursionCacheTime)
{
return(s_incursions);
}
EsiResponse <List <Incursion> > incursionResponse = await s_client.Incursions.All();
if (incursionResponse.StatusCode != HttpStatusCode.OK)
{
// Note: not sure if this message is the correct property
Console.WriteLine("[Error] Unable to query ESI for the lastest incursions. Status: {0} Error {1}", incursionResponse.StatusCode, incursionResponse.Message);
return(s_incursions);
}
return(incursionResponse.Data);
}
public void CreateResponseFromString()
{
var stubbedData = "this should be parsed correctly";
var response = new EsiResponse <string>(HttpStatusCode.OK, stubbedData);
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(stubbedData)
};
// ParseResponse will call ReadAsStringAsync on the underlying HttpContent object.
// Really this should be mocked but as we are controlling the content, I am putting trust in System.Net.Http.
var result = _responseFactory.Create <string>(httpResponse);
Assert.IsTrue(result.Success);
Assert.IsNull(result.Data);
Assert.IsNull(result.Error);
Assert.AreEqual(result.StatusCode, result.StatusCode);
Assert.AreEqual(response.Message, result.Message);
}
public static async Task <Region> GetRegion(int id)
{
Region region = RedisHelper.Get <Region>(string.Format("esi:regions:{0}", id));
if (region != null)
{
return(region);
}
EsiResponse <Region> response = await s_client.Universe.Region(id);
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("[Error] Unable to query ESI for a region. Status: {0} Error {1}", response.StatusCode, response.Message);
return(null);
}
RedisHelper.Set <Region>(string.Format("esi:regions:{0}", id), response.Data);
return(response.Data);
}
/// <summary>
/// Request an alliance's information through ESI
/// </summary>
/// <param name="id">Target alliance Id</param>
/// <see cref="ESI.NET.Models.Alliance.Alliance"/>
/// <returns>ESI Aliance Model</returns>
public static async Task <ESI.NET.Models.Alliance.Alliance> GetAlliance(int id)
{
EnsureInit();
try
{
EsiResponse <ESI.NET.Models.Alliance.Alliance> Alliance_response = await s_client.Alliance.Information(id);
if (Alliance_response.StatusCode != HttpStatusCode.OK)
{
s_Log.LogError("{0} error search API '{1}': {2}", Alliance_response.StatusCode, Alliance_response.Endpoint, Alliance_response.Message);
return(null);
}
return(Alliance_response.Data);
}
catch (Exception ex)
{
s_Log.LogError($"Error getting alliance information {ex.Message}");
return(null);
}
}
