public static IOutcome <List <PlayerMod> > GetModsFromIdList(ZelusDbContext db, List <int> modIds)
{
//Only allow saving of exactly 6 mods for a modset
if (modIds.IsNull() || modIds.Count != 6)
{
return(Outcomes.Failure <List <PlayerMod> >()
.WithMessage("Can only save 6 mods to a mod set."));
}
var mods = db.PlayerMods
.Where(pm => modIds.Contains(pm.Id))
.ToList();
//Only allow 1 of each slot of mods
if (mods.Count(pm => pm.SlotId == (int)ModSlots.Square) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Arrow) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Diamond) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Triangle) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Circle) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Cross) != 1)
{
return(Outcomes.Failure <List <PlayerMod> >()
.WithMessage("Can only save 1 mod per slot."));
}
return(Outcomes.Success <List <PlayerMod> >()
.WithValue(mods));
}
public ActionResult Unplanned(int id)
{
var db = new ZelusDbContext();
var player = db.Players.FirstOrDefault(p => p.Id == id);
if (player.IsNull())
{
return(View("Error"));
}
var mods = db.PlayerModsWithStats
.Where(PlayerModsWithStat.BelongsToPlayer(player.Id))
.ToList();
var modVMs = ModVMFactory.GetModVMs(mods, player.Id, true);
var charVMs = ModVMFactory.GetCharacterVMs(db);
var model = new ModPlannerVM
{
PlayerId = player.Id,
LastSyncDateTime = player.LastModSync,
LastSyncHumanized = player.LastModSync.Humanize(),
Mods = modVMs,
Characters = charVMs
};
return(View(model));
}
public JsonResult SaveModSet(int playerId, List <int> modIds)
{
var db = new ZelusDbContext();
//Ensure that what was passed is what we expect
var modsOutcome = PlayerModSetManager.GetModsFromIdList(db, modIds);
if (modsOutcome.Failure)
{
return(Json(modsOutcome, JsonRequestBehavior.AllowGet));
}
//Remove any previous modsets these mods were a part of
foreach (var mod in modsOutcome.Value)
{
PlayerModSetManager.RemoveModFromAllSets(db, mod);
}
var set = new PlayerModSet
{
PlayerId = playerId,
Mod1Id = modIds[0],
Mod2Id = modIds[1],
Mod3Id = modIds[2],
Mod4Id = modIds[3],
Mod5Id = modIds[4],
Mod6Id = modIds[5]
};
db.PlayerModSets.Add(set);
db.SaveChanges();
return(Json(Outcomes.Success(), JsonRequestBehavior.AllowGet));
}
public static void RemoveModFromAllSets(ZelusDbContext db, PlayerMod mod)
{
if (mod.Mod1.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod1);
}
if (mod.Mod2.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod2);
}
if (mod.Mod3.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod3);
}
if (mod.Mod4.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod4);
}
if (mod.Mod5.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod5);
}
if (mod.Mod6.Any())
{
db.PlayerModSets.RemoveRange(mod.Mod6);
}
db.SaveChanges();
}
public JsonResult Collections(int id)
{
var db = new ZelusDbContext();
var guilds = db.Guilds
.Where(g => g.SwgohGgId == id)
.Select(GuildSimplifier.SimpleGuildWithCollections)
.ToList();
return(BigJson(guilds));
}
public ActionResult Collection(int id)
{
var db = new ZelusDbContext();
var players = db.Players
.Where(p => p.Id == id)
.Select(PlayerSimplifier.SimplePlayerWithCollection)
.ToList();
return(BigJson(players));
}
public JsonResult Collections(int id)
{
var db = new ZelusDbContext();
var alliances = db.Alliances
.Where(a => a.Id == id)
.Select(AllianceSimplifier.SimpleAllianceWithCollection)
.ToList();
return(BigJson(alliances));
}
private List <PlayerCharacterViewModel> GetTopCharacters(ZelusDbContext db, int guildId, int numOfTopCharacters)
{
var topPlayerCharacters = db.Guilds
.Where(g => g.Id == guildId)
.SelectMany(g => g.Players)
.SelectMany(p => p.PlayerCharacters)
.OrderByDescending(pc => pc.Power)
.Take(numOfTopCharacters)
.ToList();
return(topPlayerCharacters.Select(GetModelForPlayerCharacter)
.ToList());
}
public ActionResult DeleteAllModSets(int id)
{
var db = new ZelusDbContext();
var sets = db.PlayerModSets
.Where(m => m.PlayerId == id)
.ToList();
db.PlayerModSets.RemoveRange(sets);
db.SaveChanges();
return(Json(Outcomes.Success(), JsonRequestBehavior.AllowGet));
}
public CollectionSynchronizer()
{
_db = new ZelusDbContext();
var timeFilter = DateTime.UtcNow.AddHours(-18);
_players = _db.Players.Where(p => p.CollectionSyncEnabled &&
p.LastCollectionSync < timeFilter)
.OrderBy(p => p.LastCollectionSync)
.ToList();
_characters = _players.SelectMany(p => p.PlayerCharacters)
.ToList();
}
public JsonResult DeleteModSet(int setId)
{
if (setId == 0)
{
return(Json(Outcomes.Failure().WithMessage("Cannot delete a modset without its id."), JsonRequestBehavior.AllowGet));
}
var db = new ZelusDbContext();
var set = db.PlayerModSets.Single(s => s.Id == setId);
db.PlayerModSets.Remove(set);
db.SaveChanges();
return(Json(Outcomes.Success(), JsonRequestBehavior.AllowGet));
}
public static List <CharacterVM> GetCharacterVMs(ZelusDbContext db)
{
var result = db.Units
.OrderBy(u => u.Name)
.Select(u => new CharacterVM {
Id = u.Id, Name = u.Name
})
.ToList();
result.Insert(0, new CharacterVM {
Id = 0, Name = "Select a character..."
});
return(result);
}
public static List <ModVM> GetModVMs(List <PlayerModsWithStat> statMods, int playerId, bool showCheckbox = false)
{
var result = new List <ModVM>();
var db = new ZelusDbContext();
var playerCharacters = db.PlayerCharacters.Where(pc => pc.PlayerId == playerId).ToList();
foreach (var mod in statMods)
{
result.Add(GetModVM(mod, playerCharacters, showCheckbox));
}
return(result);
}
public ActionResult PlannedMods(int playerId, List <string> setNames)
{
var db = new ZelusDbContext();
var query = PlayerModSet.BelongsToPlayer(playerId)
.And(PlayerModSet.HasSetBonus(setNames));
var sets = db.PlayerModSets
.Where(query)
.ToList();
var models = ModVMFactory.GetSetVMs(sets);
return(PartialView("_DoubleColumnMods", models));
}
public ModSynchronizer()
{
_db = new ZelusDbContext();
var timeFilter = DateTime.UtcNow.AddHours(-18);
_players = _db.Players.Where(p => p.ModSyncEnabled &&
p.LastModSync < timeFilter)
.Include(p => p.PlayerCharacters)
.OrderBy(p => p.LastModSync)
.Take(2)
.ToList();
_mods = _players.SelectMany(p => p.PlayerMods)
.ToList();
}
public ActionResult Planned(int id)
{
var db = new ZelusDbContext();
var player = db.Players.FirstOrDefault(p => p.Id == id);
if (player.IsNull())
{
return(View("Error"));
}
var model = new ModPlannerVM();
model.PlayerId = player.Id;
model.LastSyncDateTime = player.LastModSync;
model.LastSyncHumanized = player.LastModSync.Humanize();
return(View(model));
}
public ActionResult CalculateStrategyForPlayer(int strategyType, string playerName)
{
if (strategyType.IsDefault())
{
return(Json(Outcomes.Failure().WithMessage("You cannot go into battle without a proper strategy!"), JsonRequestBehavior.AllowGet));
}
var db = new ZelusDbContext();
var player = db.Players.FirstOrDefault(p => string.Compare(p.SwgohGgName, playerName, StringComparison.OrdinalIgnoreCase) == 0);
if (player.IsNull())
{
return(Json(Outcomes.Failure().WithMessage("We cannot find a pawn-Err ..ahem, loyal soldier with that name."), JsonRequestBehavior.AllowGet));
}
var type = (StrategyType)strategyType;
var strategy = GetStrategyFromType(type);
var planner = new PlanningService();
var planOutcome = planner.Execute(strategy, db, player);
return(Json(planOutcome, JsonRequestBehavior.AllowGet));
}
public List <PlayerMod> Execute(ZelusDbContext db, List <Player> playerToScrapeFor)
{
var results = new List <PlayerMod>();
var units = db.Units.ToList();
foreach (var player in playerToScrapeFor)
{
var modContainers = GetModContainers(player);
if (modContainers == null)
{
return(results);
}
foreach (var container in modContainers)
{
var mod = container.ParseMod(player, units);
results.Add(mod);
}
}
return(results);
}
public List <PlayerCharacter> Execute(ZelusDbContext db, List <Player> playersToScrapeFor)
{
var results = new List <PlayerCharacter>();
var units = db.Units.ToList();
foreach (var player in playersToScrapeFor)
{
var characterContainers = GetCharacterNodes(player);
if (characterContainers == null)
{
return(results);
}
foreach (var container in characterContainers)
{
var character = container.ParseCharacter(units, player.Id);
results.Add(character);
}
}
return(results);
}
/// <summary>
/// Using the guild's home page url, this function will load and parse all the player entities out
/// </summary>
public List <Player> Execute(ZelusDbContext db)
{
var results = new List <Player>();
var web = new HtmlWeb();
var guilds = db.Guilds.ToList();
foreach (var guild in guilds)
{
var guildHome = web.Load(guild.SwgohGgUrl);
var playerRows = guildHome.DocumentNode
.Descendants("tbody")
.First()
.Descendants("tr")
.ToList();
foreach (var row in playerRows)
{
var player = row.Descendants("td").ParsePlayer(guild.Id);
results.Add(player);
}
}
return(results);
}
public UnitSynchronizer()
{
_api = new SwgohGgApi();
_db = new ZelusDbContext();
_units = _db.Units.ToList();
}
public PlayerSynchronizer()
{
_db = new ZelusDbContext();
_players = _db.Players.ToList();
}
public IOutcome <StrategyResultViewModel> Execute(PlanningStrategyBase strategy, ZelusDbContext db, Player player)
{
var topCharacters = GetTopCharacters(db, player.GuildId, strategy.NumberOfTopCharacters);
return(strategy.Plan(player, topCharacters));
}
