public async Task <Participation> CreateRedeemParticipationToken(string tinyTokenId, string userId)
{
var token = await _db.ParticipationTokens
.FirstOrDefaultAsync(s => s.TinyTokenId == tinyTokenId);
if (token == null)
{
throw new NoMatchFoundException("Invalid Token");
}
if (DateTime.Compare(token.ExpirationDate, DateTime.UtcNow) < 0)
{
throw new SecurityTokenExpiredException("Token is expired");
}
var participation = new Participation()
{
ParticipationTokenId = token.Id,
UserId = userId
};
//Add new participation entry
await _db.Participation.AddAsync(participation);
//Get the token
var participationToken = await _db.ParticipationTokens.FirstOrDefaultAsync(s => s.Id == token.Id);
//Decrement remaining uses
participationToken.UsesRemaining = participationToken.UsesRemaining - 1;
await _db.SaveChangesAsync();
return(participation);
}
public async Task <IActionResult> UpdateResourcePrices([FromBody] List <Resource> resources)
{
foreach (var resource in resources)
{
_db.Entry(resource).State = EntityState.Modified;
}
await _db.SaveChangesAsync();
return(Ok(resources));
}
private static async Task GetPlanetInformation()
{
var solarSystemIds = await _db.Systems.Select(s => s.EveOnlineId).ToListAsync();
var dbPlanets = await _db.Planets.ToListAsync();
foreach (var solarSystemId in solarSystemIds)
{
try
{
var solarSystem = await
$"https://esi.evetech.net/latest/universe/systems/{solarSystemId}/?datasource=tranquility&language=en-us"
.GetJsonAsync <ViewModels.System>();
Console.WriteLine($"Getting information from {solarSystem.Name}");
foreach (var planetBase in solarSystem.Planets)
{
try
{
var planet = await $"https://esi.evetech.net/latest/universe/planets/{planetBase.PlanetId}/?datasource=tranquility"
.GetJsonAsync <ViewModels.Planet>();
Console.WriteLine($"Updating {planet.Name}");
var dbPlanet = dbPlanets.FirstOrDefault(x => x.Name.Contains(planet.Name));
if (dbPlanet == null)
{
continue;
}
dbPlanet.EveOnlineTypeId = planet.TypeId;
dbPlanet.EveOnlineId = planet.PlanetId;
_db.Entry(dbPlanet).State = EntityState.Modified;
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
await _db.SaveChangesAsync();
}
public async Task <BuybackRequest> CreateBuyBackRequest(List <ResourceOrder> resources, int pilotId)
{
double total = 0;
var taxList = await _db.Taxes.ToDictionaryAsync(x => x.Id, y => y.SellTax);
double taxPercent = 0;
foreach (var resource in resources)
{
var dbResource = await _db.Resources.FirstOrDefaultAsync(s => s.Id == resource.ResourceId);
int taxId = dbResource.TaxId ?? 0;
if (taxId != 0 && taxList.ContainsKey(taxId))
{
taxPercent = taxList[taxId] ?? 0;
}
if (dbResource == null)
{
continue;
}
total += resource.Quantity * dbResource.Price * ((float)(100 - taxPercent) / 100);
}
var pilot = await _db.PilotNames.FirstOrDefaultAsync(s => s.Id == pilotId);
var order = new BuybackRequest()
{
Pilot = pilot,
Resources = resources,
TotalPrice = total
};
var savedOrder = await _db.BuyBackRequests.AddAsync(order);
await _db.SaveChangesAsync();
return(order);
}
public async Task <IActionResult> UpdateProfile([FromBody] UserViewModel user)
{
var raidUser = await _userManager.Users.Include(s => s.PilotNames)
.SingleOrDefaultAsync(s => s.Id == user.Id.ToString());
if (!string.IsNullOrEmpty(user.DiscordUser))
{
raidUser.DiscordUser = user.DiscordUser;
}
if (raidUser == null)
{
return(NotFound());
}
foreach (var pilotName in raidUser.PilotNames)
{
if (user.PilotNames.Select(s => s.Name).Contains(pilotName.Name))
{
continue;
}
_db.PilotNames.Remove(pilotName);
}
foreach (var pilotName in user.PilotNames)
{
if (raidUser.PilotNames.Select(s => s.Name).Contains(pilotName.Name))
{
continue;
}
await _db.PilotNames.AddAsync(new PilotName()
{
User = raidUser,
Name = pilotName.Name
});
}
await _db.SaveChangesAsync();
return(Ok(_mapper.Map <UserViewModel>(raidUser)));
}
private static async Task UpdateOrCreatePlanetResources(List <PlanetInfoCsv> planetInfo)
{
var planetGroups = planetInfo.GroupBy(g => g.PlanetId);
foreach (var resouceList in planetGroups.Select(s => s.ToList()))
{
try
{
var planetBase = resouceList.FirstOrDefault(p => !string.IsNullOrEmpty(p.Region) && !string.IsNullOrEmpty(p.Constellation) && !string.IsNullOrEmpty(p.System) && !string.IsNullOrEmpty(p.PlanetName));
if (planetBase == null)
{
continue;
}
Console.WriteLine($"Adding planet {planetBase.PlanetName}");
var region = await _db.Regions.FirstOrDefaultAsync(r =>
r.Name == planetBase.Region);
if (region == null)
{
region = new Region()
{
Name = planetBase.Region
};
await _db.Regions.AddAsync(region);
await _db.SaveChangesAsync();
}
var constellation = await _db.Constellations.FirstOrDefaultAsync(c =>
c.Name == planetBase.Constellation);
if (constellation == null)
{
constellation = new Constellation()
{
Name = planetBase.Constellation,
Region = region
};
await _db.Constellations.AddAsync(constellation);
await _db.SaveChangesAsync();
}
var system = await _db.Systems.FirstOrDefaultAsync(c =>
c.Name == planetBase.System);
if (system == null)
{
system = new UniverseSystem()
{
Name = planetBase.System,
Constellation = constellation
};
await _db.Systems.AddAsync(system);
await _db.SaveChangesAsync();
}
var planet = await _db.Planets.FirstOrDefaultAsync(p => p.Id == planetBase.PlanetId);
Enum.TryParse(planetBase.PlanetType.RemoveWhitespace(), out PlanetTypes planetEnum);
if (planet == null)
{
planet = new Planet()
{
Name = planetBase.PlanetName,
Id = planetBase.PlanetId,
Type = planetEnum,
System = system,
};
await _db.Planets.AddAsync(planet);
await _db.SaveChangesAsync();
}
planet.Resources = new List <PlanetResource>();
foreach (var resource in resouceList)
{
Enum.TryParse(resource.Resource.RemoveWhitespace(), out PlanetResourceTypes resourceEnum);
Enum.TryParse(resource.Richness.RemoveWhitespace(), out ResourceRichnessTypes richnessEnum);
var dbResource = new PlanetResource()
{
Planet = planet,
Output = Double.Parse(resource.Output),
Type = resourceEnum,
Richness = richnessEnum
};
await _db.PlanetResources.AddAsync(dbResource);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
await _db.SaveChangesAsync();
}
