public async Task <ActionResult <UserGame> > PostUserGame(UserGame userGame)
{
_context.UserGame.Add(userGame);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserGame", new { id = userGame.UserGameID }, userGame));
}
public bool CreateOrder(int userId, ShoppingCart shoppingCart)
{
using (GameStoreDbContext database = new GameStoreDbContext())
{
User user = database.Users.Include(u => u.Games).FirstOrDefault(u => u.Id == userId);
if (user == null)
{
return(false);
}
foreach (int gameId in shoppingCart.GameIds)
{
UserGame order = new UserGame
{
UserId = user.Id,
GameId = gameId
};
user.Games.Add(order);
}
database.SaveChanges();
return(true);
}
}
public async Task <ActionResult> Edit(UserGame usergame)
{
try
{
string username = ViewBag.LoggedInUser;
HttpRequestMessage request = CreateRequest(HttpMethod.Post, $"api/Review/{username}/{usergame.Game.GameId}", new ScoreReview {
Review = usergame.Review, Score = usergame.Score
});
HttpResponseMessage response = await Client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
return(RedirectToAction("Login", "Account"));
}
return(View());
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public UserGame GetByUserIdAndOficialGameId(int userId, int oficialGameId)
{
UserGame userGame = new UserGame();
using (SqlConnection conn = new SqlConnection(ConnectionString())) {
using (var cmd = new SqlCommand()) {
cmd.Connection = conn;
cmd.CommandText = _userGameSql.SqlGetByUserIdAndOficialGameId();
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@UserId", GetDbValue(userId));
cmd.Parameters.AddWithValue("@OficialGameId", GetDbValue(oficialGameId));
conn.Open();
using (DbDataReader dr = cmd.ExecuteReader()) {
if (dr.Read())
{
userGame.OficialGameId = Convert.ToInt32(dr["OficialGameId"].ToString());
userGame.ScoreTeamA = Convert.ToInt32(dr["ScoreTeamA"].ToString());
userGame.ScoreTeamB = Convert.ToInt32(dr["ScoreTeamB"].ToString());
userGame.OficialGame = new OficialGame();
userGame.OficialGame.Date = Convert.ToDateTime(dr["GameDate"].ToString());
}
}
}
}
return(userGame);
}
public bool DeclineInvitation(UserGame userGame, string username)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string QUERY = @"SELECT id FROM users WHERE username = @username";
SqlCommand cmd = new SqlCommand(QUERY, conn);
cmd.Parameters.AddWithValue("@username", username);
int userId = Convert.ToInt32(cmd.ExecuteScalar());
if (userId != userGame.UserId)
{
return(false);
}
QUERY = @"UPDATE users_game
SET users_id = @userId, game_id = @gameId, status = 'rejected'
WHERE users_id = @userId AND game_id = @gameId";
cmd = new SqlCommand(QUERY, conn);
cmd.Parameters.AddWithValue("@userId", userGame.UserId);
cmd.Parameters.AddWithValue("@gameId", userGame.GameId);
cmd.ExecuteNonQuery();
}
}
catch
{
throw;
}
return(true);
}
public bool JoinGame(Guid gameId)
{
var game = _db.Games.Include(x => x.UserGames).SingleOrDefault(x => x.GameId == gameId);
if (_activeUser == "")
{
return(false);
}
UserGame ug = new UserGame {
GameId = game.GameId,
UserId = _activeUser,
User = GetUser(_activeUser),
PlayerState = Models.Enums.PlayerState.ShipPlacing
};
if (game.UserGames != null)
{
if (game.UserGames.Count() < game.MaxPlayers)
{
_session.Save("GameId", gameId);
game.UserGames.Add(ug);
_session.Save("GameId", game.GameId);
_db.UserGames.Add(ug);
_db.SaveChanges();
CreateBattleField(ug);
_db.SaveChanges();
return(true);
}
}
return(false);
}
// call the hub client method (send the new cell info):
// create a hub method that calls the client
// call the hub method from the Game 'playgame' routines
public void PlayActiveGame(UserGame game)
{
//
//game.GameRunning = true;
ConvertCells(game.Cells);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
//PlayGame playGameTask = new PlayGame(PlayGameAsync);
Task playGameTask = PlayGameAsync(cancellationTokenSource.Token);
//var signal = new ManualResetEventSlim();
//StopRequested += delegate { signal.Set(); };
//SpinWait.SpinUntil()
//while (!StopRequested)
//{
// yield return null;
//}
cancellationTokenSource.Cancel();
try
{
playGameTask.Wait(cancellationTokenSource.Token);
}
catch (OperationCanceledException)
{ }
}
public IHttpResponse Buy(int id)
{
var game = this.Db.Games.FirstOrDefault(g => g.Id == id);
if (game == null)
{
return(this.BadRequestError("Game do not exist."));
}
var currentUser = this.Db.Users.First(u => u.Email == this.User.Info);
var isGameBought = currentUser.Games.Any(g => g.GameId == id);
if (isGameBought)
{
return(this.Redirect("/games/owned"));
}
var usergame = new UserGame()
{
GameId = id,
UserId = currentUser.Id
};
this.Db.UserGames.Add(usergame);
this.Db.SaveChanges();
return(this.Redirect("/games/owned"));
}
public void SetHangmanScore(int score, int userId)
{
UserGame userGame = BusinessStructure.Instance.Model.UserGames.First(item => item.UserId == userId);
userGame.Hangman = score;
BusinessStructure.Instance.Model.SaveChanges();
}
public ActionResult SaveGame(UserGame data)
{
// Create a new UserGame
UserGame saveGame = new UserGame();
// Save gamestate data to new instance on UserGame
saveGame.UserGameID = data.UserGameID;
saveGame.UserID = data.UserID;
saveGame.Cells = (string)(Session["Cells"]);
saveGame.Height = data.Height;
saveGame.Width = data.Width;
saveGame.Name = data.Name;
//we need to find the logged on user.
var user = db.Users.Find(Session["UserID"]);
saveGame.User = user;
// Add saveGame to database
db.UserGames.Add(saveGame);
db.SaveChanges();
Object returnObj = new { Result = true };
return(Json(returnObj, JsonRequestBehavior.AllowGet));
}
// Use this for initialization
void Start()
{
HideDialogsStart();
// PreLoadDb.Inst().CreateDb();
User user = DbMngr.Inst().UserController.FindByUserName("admin");
GameManager.User = user;
if (GameManager.User != null)
{
UserGame game = DbMngr.Inst().UserGameController.FindByIdUser(GameManager.User.IdUser);
if (game != null)
{
Bank bank = DbMngr.Inst().BankController.FindById(game.Bank);
Scenario scenario = DbMngr.Inst().ScenarioController.FindById(game.Scenario);
GameUserData gameUserData = new GameUserData {
Bank = bank,
Scenario = scenario,
UGame = game
};
GameManager.GameData = gameUserData;
}
Init();
}
else
{
ReturnToMenu(false);
}
}
public ActionResult CreateFromTemplate(int UserTemplateID)
{
ViewBag.Email = Session["UserEmail"];
ViewBag.LoggedOnUser = Session["UserID"];
if (ViewBag.LoggedOnUser == null)
{
ViewBag.LoggedOnUser = 1;
}
ViewBag.TemplateID = UserTemplateID;
//get our template
var temp = db.UserTemplates.Find(UserTemplateID);
ViewBag.Template = temp;
UserGame Item = new UserGame();
Item.UserID = ViewBag.LoggedOnUser;
//Set some default values
Item.Height = temp.Height;
Item.Width = temp.Width;
ViewBag.HTMLcells = GameToHTML(CellsToGrid(ViewBag.Template));
return(View("Create", Item));
}
/// <summary>
/// Write INI setting file content if different.
/// </summary>
/// <param name="fix">True - fix the issue, false - return status only.</param>
/// <param name="game"></param>
/// <returns></returns>
/// <remarks>Game INI file location will be determined from game settings.</remarks>
GameRefreshStatus CheckSettingFileContent(bool fix, UserGame game)
{
var settingsDirectory = game.GetLibraryAndSettingsDirectory();
var fullName = Path.Combine(settingsDirectory.FullName, IniFileName);
var content = GetIniContent(game);
var bytes = SettingsHelper.GetFileContentBytes(content, Encoding.Unicode);
var isDifferent = SettingsHelper.IsDifferent(fullName, bytes);
if (isDifferent)
{
if (fix)
{
File.WriteAllBytes(fullName, bytes);
saveCount++;
var ev = ConfigSaved;
if (ev != null)
{
ev(this, new SettingEventArgs(typeof(PadSetting).Name, saveCount));
}
}
else
{
var iniExists = File.Exists(fullName);
return(iniExists
? GameRefreshStatus.IniDifferent
: GameRefreshStatus.IniNotExist);
}
}
return(GameRefreshStatus.OK);
}
public ActionResult Put(string username, int id, [FromBody] UserGame value)
{
UserGame review;
try
{
review = Repo.GetUserGame(username, id);
}
catch (Exception ex)
{
return(StatusCode(500));
}
if (review == null)
{
return(NotFound());
}
if (review.User.UserName != value.User.UserName)
{
return(BadRequest("cannot change ID"));
}
try
{
Repo.UpdateReview(value);
}
catch (Exception ex)
{
// internal server error
return(StatusCode(500));
}
return(NoContent());
}
public UserGame Update(UserGame updatedUserGame)
{
DeleteById(updatedUserGame.Id);
UserGames.Add(updatedUserGame);
return(updatedUserGame);
}
public void Reset(int userId)
{
User user = BusinessStructure.Instance.Model.Users.First(item => item.Id == userId);
user.UserScores.First().Score = 0;
UserSmallMedal smallMedals = user.UserSmallMedals.First();
smallMedals.BronzeMedals = 0;
smallMedals.SilverMedals = 0;
smallMedals.GoldMedals = 0;
UserBigMedal bigMedals = user.UserBigMedals.First();
bigMedals.BronzeMedals = 0;
bigMedals.SilverMedals = 0;
bigMedals.GoldMedals = 0;
UserCup userCup = user.UserCups.First();
userCup.AddCup = 0;
userCup.DiffCup = 0;
userCup.DivCup = 0;
userCup.MulCup = 0;
UserGame userGame = user.UserGames.First();
userGame.Hangman = 0;
userGame.Blocks = 0;
BusinessStructure.Instance.Model.SaveChanges();
}
public ActionResult PostGame(string username, int id, [FromBody] DateTime purchaseDate)
{
UserGame userGame;
try
{
User user = Repo.GetUser(username);
Game game = Repo.GetGame(id);
if (user == null || game == null)
{
return(StatusCode(400));
}
userGame = new UserGame {
User = user, Game = game, PurchaseDate = purchaseDate
};
bool check = Repo.AddUserGame(userGame);
//check is for checking if the username already exists, and if it does return status code 409
if (!check)
{
return(StatusCode(409));
}
}
catch (Exception)
{
return(StatusCode(500));
}
return(CreatedAtRoute("GetUserGame", new { username = userGame.User.UserName, id = userGame.Game.GameId }, userGame));
}
public UserGame Add(User user, TigerGame game)
{
var selectedUser = _context.Users.Where(u => u.UserName == user.UserName).FirstOrDefault();
var selectedGame = _context.Games.Where(g => g.GameName == game.GameName).FirstOrDefault();
if (selectedUser != null && selectedGame != null)
{
try
{
var newUserGame = new UserGame
{
UserID = selectedUser.Id,
GameID = selectedGame.Id
};
_context.UserGames.Add(newUserGame);
_context.SaveChanges();
return(newUserGame);
}catch (Exception ex)
{
Console.WriteLine($"{ex.Source}: {ex.Message}");
}
}
return(null);
}
public void Create()
{
var userGameRepository = new UserGameRepository(Database.Context.Instance);
var game = new Game()
{
Id = 1,
Name = "Game"
};
var user = new User()
{
Id = 0,
FirstName = "Daniel",
LastName = "Cardoza",
};
var userGame = new UserGame()
{
Id = 0,
UserId = user.Id,
User = user,
GameId = game.Id,
Game = game,
Score = 1000
};
userGameRepository.Create(userGame);
}
public async Task <JsonResult> Post([FromBody] UserGame value)
{
if (value == null)
{
return(Json(SimpleResponse.Error("Invalid value")));
}
var claims = User.Claims;
var claim = claims.FirstOrDefault(x => x.Type == CustomClaimTypes.OwnsUserGame);
int id = int.Parse(claim.Value);
if (id != value.Id)
{
return(Json(SimpleResponse.Error("Invalid value")));
}
var userGame = await _repo.GetUserGame(id);
if (userGame != null)
{
var result = await _repo.ReplaceUserGame(id, value);
return(Json(SimpleResponse.Success()));
}
else
{
await _repo.AddUserGame(value);
return(Json(SimpleResponse.Success()));
}
}
public GameBoardModel(IList <NavyBattlePiece> navyBattlePieces, UserGame userGame, string userName)
{
_navyBattlePieces = navyBattlePieces;
UserGame = userGame;
Game = userGame.Game;
UserName = userName;
}
public void StartGame(int gameSize)
{
if (_activeUser == "")
{
return;
}
Game tempGame = new Game {
GameId = Guid.NewGuid(),
MaxPlayers = 2,
GameSize = gameSize,
GameState = Models.Enums.GameState.Setup,
OwnerId = _activeUser,
CurrentPlayerId = _activeUser,
};
UserGame ug = new UserGame {
GameId = tempGame.GameId,
UserId = _activeUser,
User = _gameLogicService.GetUser(_activeUser),
PlayerState = Models.Enums.PlayerState.ShipPlacing
};
tempGame.UserGames = new List <UserGame>();
tempGame.UserGames.Add(ug);
_session.Save("GameId", tempGame.GameId);
_db.Games.Add(tempGame);
_db.UserGames.Add(ug);
_db.SaveChanges();
_gameLogicService.CreateBattleField(ug);
_db.SaveChanges();
}
///// <summary>
///// Write game settings to INI file.
///// </summary>
///// <param name="game"></param>
//public string GetIniContent(Game game)
//{
// // Get game directory.
// var dir = new FileInfo(game.FullPath).Directory;
// // Get INI file.
// var iniFile = dir.GetFiles(IniFileName).FirstOrDefault();
// var ini = new Ini(iniFile.FullName);
// var optionKeys = new[] { SettingName.PAD1, SettingName.PAD2, SettingName.PAD3, SettingName.PAD4 };
// for (int i = 0; i < optionKeys.Length; i++)
// {
// var optionKey = optionKeys[i];
// var mapTo = (MapTo)(i + 1);
// // Write PADx.
// var mapItem = SettingsMap.FirstOrDefault(x => x.IniSection == OptionsSection && x.IniKey == optionKey);
// WriteSettingsToIni(mapItem);
// var settings = SettingManager.Settings.Items.Where(x => x.MapTo == (int)mapTo).ToArray();
// for (int s = 0; s < settings.Length; s++)
// {
// var setting = settings[i];
// var padSetting = SettingManager.GetPadSetting(setting.PadSettingChecksum);
// var padSectionName = string.Format("IG_{0:N}", setting.InstanceGuid);
// WritePadSettingsToIni(padSectionName, setting, padSetting);
// }
// }
// return null;
//}
/// <summary>
/// Write game settings to INI file.
/// </summary>
/// <param name="game"></param>
public string GetIniContent2(UserGame game)
{
// Get game directory.
var dir = new FileInfo(game.FullPath).Directory;
// Get INI file.
var iniFile = dir.GetFiles(IniFileName).FirstOrDefault();
var ini = new Ini(iniFile.FullName);
var optionKeys = new[] { SettingName.PAD1, SettingName.PAD2, SettingName.PAD3, SettingName.PAD4 };
for (int i = 0; i < optionKeys.Length; i++)
{
var optionKey = optionKeys[i];
var mapTo = (MapTo)(i + 1);
// Write PADx.
var mapItem = SettingsMap.FirstOrDefault(x => x.IniSection == OptionsSection && x.IniKey == optionKey);
WriteSettingsToIni(mapItem);
var settings = SettingsManager.Settings.Items.Where(x => x.MapTo == (int)mapTo).ToArray();
for (int s = 0; s < settings.Length; s++)
{
var setting = settings[i];
var padSetting = SettingsManager.GetPadSetting(setting.PadSettingChecksum);
var padSectionName = string.Format("IG_{0:N}", setting.InstanceGuid);
WritePadSettingsToIni(padSectionName, setting, padSetting);
}
}
return(null);
}
private void GetTeachersStudents()
{
dsStudentsLocal.Students.Clear();
var studentsList = BusinessStructure.Instance.BDService.GetTeachersStudents(BusinessStructure.Instance.UserId);
foreach (User student in studentsList)
{
dsStudents.StudentsRow studentRow = dsStudentsLocal.Students.NewStudentsRow();
studentRow.Id = student.Id;
studentRow.Name = student.Username;
studentRow.Score = student.UserScores.First().Score;
UserSmallMedal smallMedals = student.UserSmallMedals.First();
studentRow.SmallBronzeMedals = smallMedals.BronzeMedals;
studentRow.SmallSilverMedals = smallMedals.SilverMedals;
studentRow.SmallGoldMedals = smallMedals.GoldMedals;
UserBigMedal bigMedals = student.UserBigMedals.First();
studentRow.BigBronzeMedals = bigMedals.BronzeMedals;
studentRow.BigSilverMedals = bigMedals.SilverMedals;
studentRow.BigGoldMedals = bigMedals.GoldMedals;
UserCup cups = student.UserCups.First();
studentRow.AddCups = cups.AddCup;
studentRow.DiffCups = cups.DiffCup;
studentRow.DivCups = cups.DivCup;
studentRow.MulCups = cups.MulCup;
UserGame games = student.UserGames.First();
studentRow.Hangman = games.Hangman;
studentRow.Blocks = games.Blocks;
dsStudentsLocal.Students.AddStudentsRow(studentRow);
}
}
public DetailPage(UserGame selectedGame)
{
//pozamieniać nazwy tychże list Obser..., jednakowość w tym przypadku not good
//dodać zabezpiecznie, że jak nie ma internetu to nie wchodzi się do części bazy "Game" poprzez if
InitializeComponent();
this.selectedGame = selectedGame;
imgBtnPlayed.BackgroundColor = Color.White;
//BindingContext to Controls
//btnMainRate.Text = selectedGame.Rate.ToString();
imgBG.Source = selectedGame.BackgroundImg;
imgCover.Source = selectedGame.Img;
//Binding List
MyGames = new ObservableCollection <UserDlc>();
/* foreach (var submenu in selectedGame.UserDlcs)
* {
* MyGames.Add(submenu);
* }*/
// LvDlcs.ItemsSource = await UserGame.GetMyDlcFromList(selectedGame);
contacts = new RateDlcVM();
BindingContext = contacts;
}
public async Task <IActionResult> PutUserGame(int id, UserGame userGame)
{
if (id != userGame.UserGameID)
{
return(BadRequest());
}
_context.Entry(userGame).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserGameExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public int Order(HashSet <IndexViewGame> orderGames, string username)
{
using (var db = new GameStoreDbContext())
{
int userId = this.Find(username).Id;
var user = db.Users
.First(u => u.Id == userId);
var userGames = db.UserGames.Where(ug => ug.UserId == userId);
foreach (var orderGame in orderGames)
{
var game = db.Games
.First(g => g.Id == orderGame.Id);
var order = new UserGame()
{
UserId = user.Id,
User = user,
GameId = game.Id,
Game = game
};
if (!userGames.Any(ug => ug.UserId == userId && ug.GameId == game.Id))
{
db.Add(order);
}
}
return(db.SaveChanges());
}
}
public async Task InitiateGame(Guid[] players)
{
try
{
Game game = new Game
{
State = GameState.PLAYERS_CONNECTING,
Link = ShortUrlGenerator.Generate(),
UserGames = players.Select(p =>
{
var x = new UserGame
{
UserId = p
};
return(x);
}).ToList()
};
_dbContext.Games.Add(game);
_dbContext.SaveChanges();
foreach (var player in players)
{
await _lobbyBroadcaster.SendGameFound(player, game.Link);
}
}
catch (Exception ex)
{
}
return;
}
public static void UpdateCurrentGame(UserGame game)
{
lock (CurrentGameLock)
{
// If nothing changed then...
if (Equals(game, CurrentGame))
{
return;
}
// Detach event from old game.
if (CurrentGame != null)
{
CurrentGame.PropertyChanged -= CurrentGame_PropertyChanged;
}
// Attach event to new game.
if (game != null)
{
game.PropertyChanged += CurrentGame_PropertyChanged;
}
// Assing new game.
CurrentGame = game;
Global.DHelper.SettingsChanged = true;
CurrentGame_PropertyChanged(null, null);
//// If pad controls not initializes yet then return.
//if (PadControls == null)
// return;
//// Update PAD Control.
//foreach (var ps in PadControls)
//{
// if (ps != null)
// ps.UpdateFromCurrentGame();
//}
}
}
/// <summary>
/// Hide devices if they are mapped to the game, unhide devices if they are not mapped.
/// </summary>
/// <returns>True if device hide/show state changed.</returns>
public static bool AutoHideShowMappedDevices(UserGame game, Guid[] instanceGuids = null)
{
var changed = false;
// Get affected devices.
UserDevice[] devices;
lock (UserDevices.SyncRoot)
devices = instanceGuids == null
? UserDevices.Items.ToArray()
: UserDevices.Items.Where(x => instanceGuids.Contains(x.InstanceGuid)).ToArray();
// Get devices instances mapped to the game.
var mappedInstanceGuids = GetMappedDevices(game?.FileName, true)
.Select(x => x.InstanceGuid).ToArray();
for (int i = 0; i < devices.Length; i++)
{
var ud = devices[i];
// Skip Keyboards and mice.
if (ud.IsKeyboard || ud.IsMouse)
{
continue;
}
// Mapped devices must be hidden.
var isHidden = mappedInstanceGuids.Contains(ud.InstanceGuid);
// If value is different then change.
if (ud.IsHidden != isHidden)
{
ud.IsHidden = isHidden;
changed = true;
}
}
return(changed);
}
public bool CompileData()
{
if (this.CompilerReady())
{
var currentTime = DateTime.Now.ToString("yyyyMMddHHmmss");
var filePath = Path.Combine(this.OutputPath, this.FileNameFormat + ".xml");
var savePath = "";
var userProfile = new UserProfile();
var profileXml = XDocument.Load(Path.Combine(this.RawDataPath, "profile.xml")).Root;
userProfile.Id = profileXml.Element("onlinename").Value;
userProfile.ImageUrl = profileXml.Element("avatarurl").Value;
userProfile.AboutMe = profileXml.Element("aboutme").Value;
userProfile.Country = profileXml.Element("country").Value;
userProfile.PSPlus = profileXml.Element("plusicon").Value == "1";
var trophyXml = XDocument.Load(Path.Combine(this.RawDataPath, "trophy.xml")).Root;
userProfile.EarnedPoints = int.Parse(trophyXml.Element("point").Value);
userProfile.Level = int.Parse(trophyXml.Element("level").Value);
userProfile.LevelProgress = int.Parse(trophyXml.Element("level").Attribute("progress").Value);
userProfile.LevelBasePoints = int.Parse(trophyXml.Element("level").Attribute("base").Value);
userProfile.LevelNextPoints = int.Parse(trophyXml.Element("level").Attribute("next").Value);
userProfile.BronzeEarned = int.Parse(trophyXml.Element("types").Attribute("bronze").Value);
userProfile.SilverEarned = int.Parse(trophyXml.Element("types").Attribute("silver").Value);
userProfile.GoldEarned = int.Parse(trophyXml.Element("types").Attribute("gold").Value);
userProfile.PlatinumEarned = int.Parse(trophyXml.Element("types").Attribute("platinum").Value);
userProfile.TotalEarned = userProfile.BronzeEarned + userProfile.SilverEarned + userProfile.GoldEarned + userProfile.PlatinumEarned;
var gamesFiles = new DirectoryInfo(this.RawDataPath).GetFiles("games_*.xml").Select(f => f.FullName);
var apiGames = new List<ApiGame>();
foreach (var gamesFile in gamesFiles)
{
var gamesXml = XDocument.Load(gamesFile).Root;
var totalGames = int.Parse(gamesXml.Element("title").Value);
if (userProfile.TotalGames == 0 || userProfile.TotalGames < totalGames)
{
userProfile.TotalGames = totalGames;
}
foreach (var game in gamesXml.Descendants("info"))
{
var gameInfo = new ApiGame();
gameInfo.Id = game.Attribute("npcommid").Value;
gameInfo.Platform = game.Attribute("pf").Value;
gameInfo.Bronze = int.Parse(game.Element("types").Attribute("bronze").Value);
gameInfo.Silver = int.Parse(game.Element("types").Attribute("silver").Value);
gameInfo.Gold = int.Parse(game.Element("types").Attribute("gold").Value);
gameInfo.Platinum = int.Parse(game.Element("types").Attribute("platinum").Value);
gameInfo.Updated = DateTime.Parse(game.Element("last-updated").Value);
var existingGame = apiGames.FirstOrDefault(g => g.Id == gameInfo.Id);
if (existingGame != null && existingGame.Updated <= gameInfo.Updated)
{
// This game is already added, but needs to be updated.
apiGames.Remove(existingGame);
apiGames.Add(gameInfo);
}
else
{
apiGames.Add(gameInfo);
}
}
}
apiGames = apiGames.OrderByDescending(g => g.Updated).ToList();
userProfile.LastUpdate = apiGames.Select(g => g.Updated).FirstOrDefault();
if (userProfile.LastUpdate == DateTime.MinValue)
{
userProfile.LastUpdate = null;
}
// Profile is done at this point.
var userGames = new List<UserGame>();
int orderPlayed = 1;
// Get game data and add to games plus create trophies- file.
foreach (var apiGame in apiGames)
{
var hasTrophyDetails = File.Exists(Path.Combine(this.TrophyDetailsPath, string.Format("{0}.xml", apiGame.Id)));
var hasEarnedDetails = File.Exists(Path.Combine(this.RawDataPath, string.Format("game-{0}.xml", apiGame.Id)));
if (hasTrophyDetails && hasEarnedDetails)
{
var trophyDetailsXml = XDocument.Load(Path.Combine(this.TrophyDetailsPath, string.Format("{0}.xml", apiGame.Id))).Root;
var earnedDetailsXml = XDocument.Load(Path.Combine(this.RawDataPath, string.Format("game-{0}.xml", apiGame.Id))).Root;
var gameDetails = trophyDetailsXml.Descendants("Game").FirstOrDefault();
var userGame = new UserGame();
userGame.Id = apiGame.Id;
userGame.IdEurope = gameDetails.Element("IdEurope").Value;
userGame.Title = gameDetails.Element("Title").Value;
userGame.ImageUrl = gameDetails.Element("Image").Value;
userGame.BronzeEarned = apiGame.Bronze;
userGame.SilverEarned = apiGame.Silver;
userGame.GoldEarned = apiGame.Gold;
userGame.PlatinumEarned = apiGame.Platinum;
userGame.TotalEarned = apiGame.Bronze + apiGame.Silver + apiGame.Gold + apiGame.Platinum;
userGame.OrderPlayed = orderPlayed++;
userGame.LastUpdated = apiGame.Updated;
userGame.TotalPoints = int.Parse(gameDetails.Element("TotalPoints").Value);
// It appears that PS4 games now include platinums in the total points count. Should probably just overwrite this for all platforms.
userGame.EarnedPoints = userGame.CalculateEarnedPoints(apiGame.Platform.ToLower() == "ps4");
userGame.Progress = userGame.CalculateProgress().ToString();
userGame.Platform = apiGame.Platform;
var trophyDetails = trophyDetailsXml.Descendants("Trophy");
userGame.PossibleTrophies = trophyDetails.Count();
userGames.Add(userGame);
// Compile trophy data.
var userTrophies = new List<UserTrophy>();
foreach (var trophyDetail in trophyDetails)
{
var userTrophy = new UserTrophy();
userTrophy.Id = trophyDetail.Element("Id").Value;
userTrophy.GameId = apiGame.Id;
userTrophy.Title = trophyDetail.Element("Title").Value;
userTrophy.ImageUrl = trophyDetail.Element("Image").Value;
userTrophy.Description = trophyDetail.Element("Description").Value;
userTrophy.Type = ParseTrophyType(trophyDetail.Element("Type").Value);
// Trophy data can now have null values for this. If that's the case, assume it's hidden to be on the safe side.
userTrophy.Hidden = !string.IsNullOrWhiteSpace(trophyDetail.Element("Hidden").Value) ? bool.Parse(trophyDetail.Element("Hidden").Value) : true;
userTrophy.Platform = apiGame.Platform;
foreach (var earnedDetail in earnedDetailsXml.Descendants("trophy"))
{
if (earnedDetail.Attribute("id").Value == userTrophy.Id)
{
userTrophy.Earned = DateTime.Parse(earnedDetail.Value).ToUniversalTime().ToLocalTime();
break;
}
}
userTrophies.Add(userTrophy);
}
PerformBackup("trophies-" + apiGame.Id, "__{0}-" + currentTime);
savePath = string.Format(filePath, "trophies-" + apiGame.Id);
SaveTrophyXml(savePath, userTrophies);
}
else
{
DebugInfo.Add(apiGame.Id);
DebugInfo.Add(hasTrophyDetails);
DebugInfo.Add(hasEarnedDetails);
}
}
#region Save data
// Profile
PerformBackup("profile", "__{0}-" + currentTime);
savePath = string.Format(filePath, "profile");
var psnProfile = new XmlSerializer(userProfile.GetType());
using (StreamWriter writer = new StreamWriter(savePath))
{
psnProfile.Serialize(writer, userProfile);
}
// Games
PerformBackup("games", "__{0}-" + currentTime);
savePath = string.Format(filePath, "games");
var psnGames = new XmlSerializer(userGames.GetType());
using (StreamWriter writer = new StreamWriter(savePath))
{
psnGames.Serialize(writer, userGames);
}
// Trophies
// done above
#endregion
return true;
}
return false;
}
