protected override void Map(HeroDto input, Hero output)
{
var gameMode = MapGameMode(input);
var characterId = EnumConversionHelper.CharacterKindFromString(input.Class);
var actives = MapActives(input.Class, input.Skills.Actives);
var passives = MapPassives(input.Class, input.Skills.Passives);
var items = MapEquipmentItems(_items);
var followerItems = MapFollowerItems(_itemsByFollower);
var cubeItems = MapCubeItems(input.LegendaryPowers);
var stats = MapStats(input.Stats);
output.Id = _heroId;
output.Level = input.Level;
output.Gender = (HeroGender)input.Gender;
output.Character = characterId;
output.Name = input.Name;
output.IsDead = false;
output.GameMode = gameMode;
output.HighestSoloRift = input.HighestSoloRiftCompleted;
output.Actives = actives;
output.Passives = passives;
output.Items = items;
output.FollowerItems = followerItems;
output.CubeItems = cubeItems;
output.Stats = stats;
}
internal BattleNetClient CreateClient(IAuthenticationScope authenticationScope)
{
authenticationScope.EnsureExpiration();
var regionString = EnumConversionHelper.RegionToString(authenticationScope.Region);
var localizationString = EnumConversionHelper.LocalizationToString(authenticationScope.Localization);
return(new BattleNetClient(authenticationScope.AccessToken, regionString, localizationString, _tokenBucket));
}
private HeroStat MapStat(KeyValuePair <string, double> input)
{
return(new HeroStat
{
Id = EnumConversionHelper.HeroStatIdentifierFromString(input.Key),
Value = input.Value
});
}
protected override void Map(ItemDto input, ItemEquipment output)
{
base.Map(input, output);
output.Kind = EnumConversionHelper.ItemEquipmentKindFromString(input.Type.Id);
output.Slots = MapSlots(input);
output.Characters = EnumConversionHelper.CharacterIdentifiersFromString(input.Type.Id);
output.IsTwoHanded = input.Type.TwoHanded;
output.Set = MapSet(input);
output.Cube = MapCube(output.Id, output.Slots.First());
}
public static IMaybe <TEnum> ToMaybeEnum <TValue, TEnum>(this TValue value)
where TValue : struct, IConvertible
where TEnum : struct, IConvertible
{
var result = EnumConversionHelper <TValue, TEnum> .Convert(value);
return(Enum.IsDefined(typeof(TEnum), result)
? result.ToMaybe()
: Maybe <TEnum> .None);
}
public async Task SetupAsync()
{
var diabloApi = DiabloApiFactory.CreateApi();
var authenticationScope = await diabloApi.CreateAuthenticationScopeAsync();
var regionString = EnumConversionHelper.RegionToString(authenticationScope.Region);
var localizationString = EnumConversionHelper.LocalizationToString(authenticationScope.Localization);
Client = new BattleNetClient(authenticationScope.AccessToken, regionString, localizationString, new DefaultTokenBucket());
}
private CharacterSkillActiveRune MapRune(string characterId, CharacterRuneDto input)
{
return(new CharacterSkillActiveRune
{
Id = new CharacterSkillId(characterId, input.Slug),
Name = input.Name,
Level = input.Level,
Character = EnumConversionHelper.CharacterKindFromString(characterId)
});
}
protected override void Map(FollowerDto input, Follower output)
{
var followerId = EnumConversionHelper.FollowerIdentifierFromString(input.Slug);
var skills = MapSkills(followerId, input.Skills);
output.Id = followerId;
output.Name = input.Name;
output.RealName = input.RealName;
output.Portrait = input.Portrait;
output.Skills = skills;
}
private HeroItemEquipment MapEquipmentItem(DetailedItemDto input)
{
var slot = EnumConversionHelper.ItemEquipmentSlotFromString(input.Slots);
var output = new HeroItemEquipment {
Slot = slot
};
MapCustomizableItem(input, output);
return(output);
}
public async Task <Recipe> GetRecipeAsync(IAuthenticationScope authenticationScope, RecipeId recipeId)
{
var mapper = new RecipeMapper(recipeId.Id);
var artisanSlug = EnumConversionHelper.ArtisanIdentifierToString(recipeId.Id);
using (var client = CreateClient(authenticationScope))
{
var recipe = await client.GetRecipeAsync(artisanSlug, recipeId.Slug);
return(mapper.Map(recipe));
}
}
private AccountFallenHero MapFallenHero(string battleTag, AccountFallenHeroDto input)
{
return(new AccountFallenHero
{
Id = new HeroId(battleTag, input.HeroId),
Name = input.Name,
Level = input.Level,
Gender = (HeroGender)input.Gender,
Character = EnumConversionHelper.CharacterKindFromString(input.Class),
IsDead = true
});
}
private IEnumerable <CharacterSkillCategory> MapSkillCategories(IEnumerable <CharacterSkillCategoryDto> inputs)
{
var outputs = new List <CharacterSkillCategory>();
foreach (var input in inputs)
{
var output = EnumConversionHelper.CharacterSkillCategoryFromString(input.Slug);
outputs.Add(output);
}
return(outputs);
}
private HeroItemFollower MapFollowerItem(FollowerId followerId, DetailedItemDto input)
{
var slot = EnumConversionHelper.ItemFollowerSlotFromString(input.Slots);
var output = new HeroItemFollower
{
Slot = slot,
Follower = followerId
};
MapCustomizableItem(input, output);
return(output);
}
protected override void Map(ItemDto input, TOut output)
{
output.Id = new ItemId(input.Slug, input.Id);
output.Name = input.Name;
output.IconUrl = input.Icon;
output.TooltipUrl = input.TooltipParams;
output.RequiredLevel = input.RequiredLevel;
output.StackSize = input.StackSizeMax;
output.AccountBound = input.AccountBound;
output.Category = _itemCategory;
output.Quality = EnumConversionHelper.ItemQualityFromString(input.Color);
}
private CharacterSkillPassive MapPassiveSkill(string characterId, CharacterSkillDto input)
{
return(new CharacterSkillPassive
{
Id = new CharacterSkillId(characterId, input.Slug),
Name = input.Name,
Level = input.Level,
TooltipUrl = input.TooltipUrl,
IconUrl = input.Icon,
Kind = CharacterSkillKind.Passive,
Character = EnumConversionHelper.CharacterKindFromString(characterId)
});
}
public async Task GetTokenAsyncTest()
{
var configuration = new DiabloApiEnvironmentConfiguration();
var regionString = EnumConversionHelper.RegionToString(configuration.Region);
using (var client = new OAuthClient(configuration.ClientId, configuration.ClientSecret, regionString, new DefaultTokenBucket()))
{
var token = await client.GetTokenAsync();
Assert.That(token.AccessToken, Is.Not.Null.Or.Empty);
Assert.That(token.Type, Is.Not.Null.Or.Empty);
Assert.NotZero(token.SecondsUntilExpiration);
}
}
public async Task <OAuthToken> GetTokenAsync(string clientId, string clientSecret, Region region)
{
var regionString = EnumConversionHelper.RegionToString(region);
using (var client = new OAuthClient(clientId, clientSecret, regionString, _tokenBucket))
{
var token = await client.GetTokenAsync();
return(new OAuthToken
{
AccessToken = token.AccessToken,
SecondsUntilExpiration = token.SecondsUntilExpiration
});
}
}
private CharacterSkillActive MapActiveSkill(string characterId, CharacterApiSkillDto input)
{
var runes = MapRunes(characterId, input.Runes);
return(new CharacterSkillActive
{
Id = new CharacterSkillId(characterId, input.Skill.Slug),
Name = input.Skill.Name,
Level = input.Skill.Level,
Character = EnumConversionHelper.CharacterKindFromString(characterId),
TooltipUrl = input.Skill.TooltipUrl,
IconUrl = input.Skill.Icon,
Kind = CharacterSkillKind.Active,
Runes = runes
});
}
private IEnumerable <ItemEquipmentSlot> MapSlots(ItemDto input)
{
var outputs = new List <ItemEquipmentSlot>();
foreach (var inputSlot in input.Slots)
{
if (!EnumConversionHelper.TryItemEquipmentSlotFromString(inputSlot, out var slot) ||
input.Type.TwoHanded && slot == ItemEquipmentSlot.Offhand)
{
continue;
}
outputs.Add(slot);
}
return(outputs);
}
protected override void Map(ArtisanDto input, Artisan output)
{
var artisanId = EnumConversionHelper.ArtisanIdentifierFromString(input.Slug);
var recipes = new List <ArtisanRecipe>();
foreach (var tier in input.Training.Tiers)
{
var rank = (ArtisanRecipeRank)tier.Index;
var taughtRecipes = MapRecipes(artisanId, rank, ArtisanRecipeSource.Taught, tier.TaughtRecipes);
var trainedRecipes = MapRecipes(artisanId, rank, ArtisanRecipeSource.Trained, tier.TrainedRecipes);
recipes.AddRange(taughtRecipes);
recipes.AddRange(trainedRecipes);
}
output.Id = artisanId;
output.Name = input.Name;
output.Portrait = input.Portrait;
output.Recipes = recipes;
}
public DiabloApiEnvironmentConfiguration()
{
ClientId = GetEnvironmentVariableThrowIfMissing(ClientIdEnvironmentKey);
ClientSecret = GetEnvironmentVariableThrowIfMissing(ClientSecretEnvironmentKey);
var regionValue = GetEnvironmentVariableThrowIfMissing(RegionEnvironmentKey);
var localizationValue = GetEnvironmentVariableThrowIfMissing(LocalizationEnvironmentKey);
if (!EnumConversionHelper.TryRegionFromString(regionValue, out var region))
{
throw new DiabloApiException($"Unable to cast value of environment variable \"{RegionEnvironmentKey}\" to {typeof(Region).Name}.");
}
if (!EnumConversionHelper.TryLocalizationFromString(localizationValue, out var localization))
{
throw new DiabloApiException($"Unable to cast value of environment variable \"{LocalizationEnvironmentKey}\" to {typeof(Localization).Name}.");
}
Region = region;
Localization = localization;
}
protected override void Map(CharacterClassDto input, Character output)
{
var characterKind = EnumConversionHelper.CharacterKindFromString(input.Slug);
var names = MapNames(input);
var categories = MapSkillCategories(input.SkillCategories);
var actives = MapActiveSkills(input.Slug, Actives)
.ToList();
var passives = MapPassiveSkills(input.Slug, input.Skills.Passives)
.ToList();
var skills = actives.Cast <CharacterSkill>().Concat(passives);
output.Id = input.Slug;
output.Name = input.Name;
output.Kind = characterKind;
output.IconUrl = input.Icon;
output.ActiveSkills = actives;
output.PassiveSkills = passives;
output.Skills = skills;
output.Names = names;
output.Categories = categories;
}
public async Task <Character> GetCharacterAsync(IAuthenticationScope authenticationScope, CharacterKind characterKind)
{
var mapper = new CharacterMapper();
var artisanSlug = EnumConversionHelper.CharacterIdentifierToString(characterKind);
using (var client = CreateClient(authenticationScope))
{
var characterClass = await client.GetCharacterClassAsync(artisanSlug);
/* GetApiSkill only extends active skills with runes, all the other properties are already retrieved via GetCharacterClass */
var activeApiSkills = new List <CharacterApiSkillDto>();
foreach (var skill in characterClass.Skills.Actives)
{
var apiSkill = await client.GetApiSkillAsync(artisanSlug, skill.Slug);
activeApiSkills.Add(apiSkill);
}
mapper.Actives = activeApiSkills;
return(mapper.Map(characterClass));
}
}
protected override void Map(ItemDto input, ItemFollowerToken output)
{
base.Map(input, output);
output.Kind = EnumConversionHelper.ItemFollowerTokenKindFromString(input.Type.Id);
}
