public GamePlayModalViewModel GetBoardgamePlaysForGame(string email, int gameid)
{
GamePlayModalViewModel model = new GamePlayModalViewModel();
UserDetails user = _context.UserDetails.Where(u => u.Email == email).FirstOrDefault();
if (user == null)
{
return(model);
}
Boardgame game = _context.Boardgames.Where(x => x.BoardgameId == gameid).FirstOrDefault();
if (game == null)
{
return(model);
}
model.BoardgameName = game.Name;
model.BoardgameId = game.BoardgameId;
model.BoardgamePlays = _context.UserBoardgamePlays
.Where(p => p.BoardgameId == game.BoardgameId && p.UserDetailId == user.UserDetailId)
.Select(ubp => new UserBoardgamePlayViewModel {
BoardgameId = ubp.BoardgameId,
PlayId = ubp.PlayId,
BoardgameName = game.Name,
DatePlayed = ubp.DatePlayed,
UserDetailId = user.UserDetailId
});
return(model);
}
public IActionResult Create(CreateBoardgameModel createBoardgame)
{
if (ModelState.IsValid)
{
var webRoot = _env.WebRootPath;
var filePath = Path.Combine(webRoot.ToString() + "\\images\\games\\" + createBoardgame.imageUpload.FileName);
if (createBoardgame.imageUpload.FileName.Length > 0)
{
using (var stream = new FileStream(filePath, FileMode.Create))
{
createBoardgame.imageUpload.CopyTo(stream);
}
}
var boardgame = new Boardgame
{
Name = createBoardgame.Name,
Description = createBoardgame.Description,
Rating = createBoardgame.Rating,
Image = "\\images\\games\\" + createBoardgame.imageUpload.FileName
};
_assets.Add(boardgame);
return(RedirectToAction("Index"));
}
return(View(createBoardgame));
}
public async Task <IEnumerable <Boardgame> > LoadHotness()
{
try
{
Uri teamDataURI = new Uri(BASE_URL + "/hot?thing=boardgame");
XDocument xDoc = await ReadData(teamDataURI);
// LINQ to XML.
IEnumerable <Boardgame> gameCollection = from Boardgame in xDoc.Descendants("item")
select new Boardgame
{
Name = Boardgame.Element("name").Attribute("value").Value,
YearPublished = Boardgame.Element("yearpublished") != null?int.Parse(Boardgame.Element("yearpublished").Attribute("value").Value) : 0,
Thumbnail = Boardgame.Element("thumbnail").Attribute("value").Value,
GameId = int.Parse(Boardgame.Attribute("id").Value)
};
return(gameCollection);
}
catch (Exception ex)
{
//ExceptionHandler(ex);
return(new List <Boardgame>());
}
}
public async Task <User> LoadUserDetails(string username)
{
try
{
Uri teamDataURI = new Uri(string.Format(BASE_URL + "/user?name={0}", username));
XDocument xDoc = await ReadData(teamDataURI);
IEnumerable <User> users = from Boardgame in xDoc.Descendants("user")
select new User
{
BggUserId = int.Parse(Boardgame.Attribute("id").Value),
Username = Boardgame.Attribute("name").Value,
Avatar = GetStringValue(Boardgame.Element("avatarlink"), "value"),
FirstName = GetStringValue(Boardgame.Element("firstname"), "value"),
LastName = GetStringValue(Boardgame.Element("lastname"), "value"),
YearRegistered = GetStringValue(Boardgame.Element("yearregistered"), "value"),
};
return(users.FirstOrDefault());
}
catch (Exception)
{
return(new User());
}
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Boardgame boardgame = db.Boardgame.Find(id);
if (boardgame == null)
{
return(HttpNotFound());
}
List <SelectListItem> items = new SelectList(db.Author, "author_id", "author_name", boardgame.author_id).ToList();
items.Insert(0, (new SelectListItem {
Text = null, Value = null,
}));
ViewBag.author_id = items;
items = new SelectList(db.Complexity, "complexity_id", "complexity_name", boardgame.complexity_id).ToList();
items.Insert(0, (new SelectListItem {
Text = null, Value = null,
}));
ViewBag.complexity_id = items;
items = new SelectList(db.Publisher, "publisher_id", "publisher_name", boardgame.publisher_id).ToList();
items.Insert(0, (new SelectListItem {
Text = null, Value = null,
}));
ViewBag.publisher_id = items;
return(View(boardgame));
}
public async Task <IEnumerable <Play> > LoadLastPlays(string Username)
{
try
{
Uri teamDataURI = new Uri(string.Format(BASE_URL + "/plays?username={0}", Username));
XDocument xDoc = await ReadData(teamDataURI);
IEnumerable <Play> gameCollection = from Boardgame in xDoc.Descendants("play")
select new Play
{
PlayId = int.Parse(Boardgame.Attribute("id").Value),
BoardGameName = Boardgame.Element("item").Attribute("name").Value,
BoardGameId = int.Parse(Boardgame.Element("item").Attribute("objectid").Value),
PlayDate = safeParseDateTime(Boardgame.Attribute("date").Value),
NumberOfPlays = int.Parse(Boardgame.Attribute("quantity").Value),
Length = int.Parse(Boardgame.Attribute("length").Value),
UserComment = GetStringValue(Boardgame.Element("comments")),
Players = LoadPlayersStatsList(Boardgame.Element("players"))
};
return(gameCollection);
}
catch (Exception)
{
return(new List <Play>());
}
}
public BoardGameEntry(Boardgame boardGame)
{
this.Name = boardGame.Name.Single(n => n.Primary).Text;
this.Description = boardGame.Description;
this.Thumbnail = boardGame.Thumbnail;
this.MinPlayers = boardGame.Minplayers;
this.MaxPlayers = boardGame.Maxplayers;
this.MinPlaytime = boardGame.Minplaytime;
this.MaxPlaytime = boardGame.Maxplaytime;
this.Image = boardGame.Image;
this.ObjectId = boardGame.Objectid;
this.YearPublished = new DateTimeOffset(new DateTime(boardGame.Yearpublished, 1, 1));
this.AverageRating = boardGame.Statistics.Ratings.Average;
this.UsersRated = boardGame.Statistics.Ratings.Usersrated;
this.Age = boardGame.Age;
var playerPoll = boardGame.Poll.FirstOrDefault(p => p.Name == "suggested_numplayers");
if (playerPoll != null)
{
int highestResult = 0;
foreach (var res in playerPoll.Results)
{
var bestResult = res.Result.First(rn => rn.Value == "Best");
if (bestResult.Numvotes > highestResult)
{
highestResult = bestResult.Numvotes;
this.BestPlayerCount = res.Numplayers;
}
}
}
}
public ActionResult DeleteConfirmed(int id)
{
Boardgame boardgame = db.Boardgames.Find(id);
db.Boardgames.Remove(boardgame);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private DetailsBoardgameViewModel GetDetailsBoardgameViewModel(Boardgame boardgame)
{
DetailsBoardgameViewModel viewModel = new DetailsBoardgameViewModel();
MapperConfiguration config = new MapperConfiguration(cfg => cfg.CreateMap <Boardgame, DetailsBoardgameViewModel>());
IMapper mapper = config.CreateMapper();
viewModel = mapper.Map(boardgame, viewModel);
return(viewModel);
}
public async Task <Boardgame> UpdategameAsync(Boardgame boardgame)
{
using (var boardgameContext = new BoardgameContext())
{
boardgameContext.Entry(boardgame).State = EntityState.Modified;
await boardgameContext.SaveChangesAsync();
}
return(boardgame);
}
private void NotifyRequestBoardgameCompleted(XDocument document)
{
Boardgame boardgame = boardgameReader.FromXml(document);
if (RequestBoardgameCompleted != null)
{
RequestBoardgameCompleted(this, new BoardgameEventArgs(boardgame));
}
}
public async Task <Boardgame> GetGameAsync(int id)
{
Boardgame result = null;
using (var boardgameContext = new BoardgameContext())
{
result = await boardgameContext.Boardgames.FirstOrDefaultAsync(f => f.ProductId == id);
}
return(result);
}
public ActionResult IntoBasket(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Boardgame boardgame = db.Boardgame.Find(id);
if (boardgame == null)
{
return(HttpNotFound());
}
User user = db.User.Find(1);
if (user.Basket != null && user.Basket.Count != 0)
{
bool flag = false;
foreach (Basket basket in user.Basket)
{
if (basket.boardgame_id == id)
{
flag = true;
break;
}
}
if (flag)
{
IncreaseOrder(id);
}
else
{
user.Basket.Add(new Models.Basket()
{
Boardgame = boardgame,
User = db.User.Find(1),
Status = db.Status.Where(s => s.status_name == "Корзина").First(),
product_number = 1
});
}
}
else
{
user.Basket.Add(new Models.Basket()
{
Boardgame = boardgame,
User = db.User.Find(1),
Status = db.Status.Where(s => s.status_name == "Корзина").First(),
product_number = 1
});
}
db.SaveChanges();
ViewBag.Sum = db.User.Find(1).Basket.Sum(b => b.product_number * b.product_number);
return(View("Basket", db.User.Find(1).Basket));
}
public async Task <Boardgame> AddGamesAsync(Boardgame bordgame)
{
Boardgame result = null;
using (var boardgameContext = new BoardgameContext())
{
result = boardgameContext.Boardgames.Add(bordgame);
await boardgameContext.SaveChangesAsync();
}
return(result);
}
public ActionResult DeleteConfirmed(int id)
{
Boardgame boardgame = db.Boardgame.Find(id);
if (boardgame.cover_path != null && boardgame.cover_path != "")
{
System.IO.File.Delete(Server.MapPath("~/Content/" + boardgame.cover_path));
}
db.Boardgame.Remove(boardgame);
db.SaveChanges();
return(RedirectToAction("Catalog", db.Boardgame));
}
private void EditBoardgame(EditBoardgameViewModel editBoardgameViewModel)
{
Boardgame boardgame = new Boardgame();
MapperConfiguration config = new MapperConfiguration(cfg => cfg.CreateMap <EditBoardgameViewModel, Boardgame>());
IMapper mapper = config.CreateMapper();
boardgame = mapper.Map <Boardgame>(editBoardgameViewModel);
boardgame.ModifiedBy = HttpContext.User.Identity.Name;
boardgame.ModifiedDate = DateTime.Now;
db.Entry(boardgame).State = EntityState.Modified;
db.SaveChanges();
}
private void AddBoardgame(CreateBoardgameViewModel viewModel)
{
Boardgame boardgame = new Boardgame();
MapperConfiguration config = new MapperConfiguration(cfg => cfg.CreateMap <CreateBoardgameViewModel, Boardgame>());
IMapper mapper = config.CreateMapper();
boardgame = mapper.Map <Boardgame>(viewModel);
boardgame.CreatedBy = HttpContext.User.Identity.Name;
boardgame.CreatedDate = DateTime.Now;
db.Boardgames.Add(boardgame);
db.SaveChanges();
}
public void Initialize()
{
b1 = new Boardgame {
BoardgameName = "Matador", PlayerCount = "4", Audience = "7+", GameTime = "45", Distributor = "HashBro", GameTag = "Family", BoardgameId = 1
};
b2 = new Boardgame {
BoardgameName = "Uno", PlayerCount = "2-4", Audience = "10+", GameTime = "30", Distributor = "HashBro", GameTag = "Family", BoardgameId = 2
};
b3 = new Boardgame {
BoardgameName = "Monsterslayer", PlayerCount = "4", Audience = "15+", GameTime = "120", Distributor = "HashBro", GameTag = "Roleplay", BoardgameId = 3
};
}
private async Task AddNewBoardgameToDB(UserBoardgameListItem boardgame)
{
var boardgameEntity = new Boardgame();
boardgameEntity.BggId = boardgame.ObjectId;
boardgameEntity.Name = boardgame.Name;
boardgameEntity.Image = boardgame.Image;
boardgameEntity.ThumbNail = boardgame.Thumbnail;
boardgameEntity.YearPublished = boardgame.YearPublished;
_dbContext.BoardGames.Add(boardgameEntity);
await _dbContext.SaveChangesAsync();
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Boardgame boardgame = db.Boardgame.Find(id);
if (boardgame == null)
{
return(HttpNotFound());
}
return(View(boardgame));
}
public string AddBoardgameToCollectionXml(string UserEmail, XmlDocument doc)
{
UserDetails user = _context.UserDetails.Where(u => u.Email == UserEmail).FirstOrDefault();
if (user == null)
{
return("Error: The email supplied is not a valid user");
}
string BggId = doc.SelectSingleNode("/boardgames/boardgame").Attributes["objectid"].Value;
Boardgame game = _context.Boardgames.Where(x => x.Bggid == BggId).FirstOrDefault();
if (game == null)
{
game = new Boardgame
{
Bggid = BggId,
MaxPlayers = short.TryParse(doc.SelectSingleNode("/boardgames/boardgame/maxplayers").InnerText, out var maxvalue) ? maxvalue : (short)0,
MinPlayers = short.TryParse(doc.SelectSingleNode("/boardgames/boardgame/minplayers").InnerText, out var minvalue) ? minvalue : (short)0,
MaxPlayTimeMinutes = short.TryParse(doc.SelectSingleNode("/boardgames/boardgame/maxplaytime").InnerText, out var maxplayvalue) ? maxplayvalue : (short)0,
MinPlayTimeMinutes = short.TryParse(doc.SelectSingleNode("/boardgames/boardgame/minplaytime").InnerText, out var minplayvalue) ? minplayvalue : (short)0,
Name = doc.SelectSingleNode("/boardgames/boardgame/name[@primary='true']").InnerText,
CoverImage = DownloadImage(doc.SelectSingleNode("/boardgames/boardgame/thumbnail").InnerText)
};
_context.Add(game);
_context.SaveChanges();
}
var ubc = _context.UserBoardgameCollections.Where(x => x.BoardgameId == game.BoardgameId && x.UserDetailId == user.UserDetailId).SingleOrDefault();
if (ubc == null)
{
var usergame = new UserBoardgameCollection
{
BoardgameId = game.BoardgameId,
UserDetailId = user.UserDetailId,
DateAdded = DateTime.Now
};
_context.Add(usergame);
_context.SaveChanges();
return("Successfully added game to your collection");
}
else
{
return("This boardgame already belongs to your collection");
}
}
public ActionResult DynamicDelete(int?id)
{
if (id == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
Boardgame boardgame = db.Boardgames.Find(id);
if (boardgame == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
db.Boardgames.Remove(boardgame);
db.SaveChanges();
return(Json(true, JsonRequestBehavior.AllowGet));
}
public BoardgameDTO Insert(Boardgame boardGame)
{
try
{
var model = _mapper.Map <BoardgameDTO>(boardGame);
var result = _repository.Boardgame.Add(model).Entity;
_repository.SaveChanges();
return(result);
}
catch (Exception e)
{
//Todo: Log error here
throw e;
}
}
// GET: Boardgames/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Boardgame boardgame = db.Boardgames.Find(id);
if (boardgame == null)
{
return(HttpNotFound());
}
EditBoardgameViewModel editBoardgameViewModel = GetEditBoardgameViewModel(boardgame);
UpdateEditBoardgameViewModel(editBoardgameViewModel);
return(View(editBoardgameViewModel));
}
// GET: Boardgames/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Boardgame boardgame = db.Boardgames.Find(id);
if (boardgame == null)
{
return(HttpNotFound());
}
UpdateBoardgameCall(boardgame.Id);
DetailsBoardgameViewModel viewmodel = GetDetailsBoardgameViewModel(boardgame);
return(View(viewmodel));
}
public IActionResult Update(UpdateBoardgameModel boardgameModel)
{
if (ModelState.IsValid)
{
var boardgame = new Boardgame
{
Id = boardgameModel.Id,
Name = boardgameModel.Name,
Image = boardgameModel.Image,
Description = boardgameModel.Description,
Rating = boardgameModel.Rating
};
if (boardgameModel.imageUpload != null)
{
if (boardgameModel.imageUpload.FileName.Length > 0)
{
var webRoot = _env.WebRootPath;
var filePath = Path.Combine(webRoot.ToString() + boardgame.Image);
if (boardgame.Image != null)
{
webRoot = _env.WebRootPath;
System.IO.File.Delete(filePath);
}
filePath = Path.Combine(webRoot.ToString() + "\\images\\games\\" +
boardgameModel.imageUpload.FileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
boardgameModel.imageUpload.CopyTo(stream);
}
boardgame.Image = "\\images\\games\\" + boardgameModel.imageUpload.FileName;
}
}
_assets.Update(boardgame);
return(RedirectToAction("Detail", new { id = boardgameModel.Id }));
}
return(View(boardgameModel));
}
public async Task <ActionResult> AddNewGame(BoardgameViewModel boardViewModel, string redirectUrl)
{
if (!ModelState.IsValid)
{
return(View(boardViewModel));
}
var boardgame = new Boardgame
{
ProductName = boardViewModel.Name,
Coast = boardViewModel.Coast,
Rang = boardViewModel.Rang,
Description = boardViewModel.Description,
Count = boardViewModel.Count
};
await _boardService.AddGamesAsync(boardgame);
return(RedirectToLocal(redirectUrl));
}
public async Task <Boardgame> LoadGame(int GameId)
{
try
{
Uri teamDataURI = new Uri(string.Format(BASE_URL + "/thing?id={0}&stats=1&comments=1", GameId));
XDocument xDoc = await ReadData(teamDataURI);
// LINQ to XML.
IEnumerable <Boardgame> gameCollection = from Boardgame in xDoc.Descendants("items")
select new Boardgame
{
Name = (from p in Boardgame.Element("item").Elements("name") where p.Attribute("type").Value == "primary" select p.Attribute("value").Value).SingleOrDefault(),
GameId = int.Parse(Boardgame.Element("item").Attribute("id").Value),
Image = Boardgame.Element("item").Element("image") != null?Boardgame.Element("item").Element("image").Value : string.Empty,
Thumbnail = Boardgame.Element("item").Element("thumbnail") != null?Boardgame.Element("item").Element("thumbnail").Value : string.Empty,
Description = Boardgame.Element("item").Element("description").Value,
MaxPlayers = int.Parse(Boardgame.Element("item").Element("maxplayers").Attribute("value").Value),
MinPlayers = int.Parse(Boardgame.Element("item").Element("minplayers").Attribute("value").Value),
YearPublished = int.Parse(Boardgame.Element("item").Element("yearpublished").Attribute("value").Value),
PlayingTime = int.Parse(Boardgame.Element("item").Element("playingtime").Attribute("value").Value),
AverageRating = decimal.Parse(Boardgame.Element("item").Element("statistics").Element("ratings").Element("average").Attribute("value").Value),
BGGRating = decimal.Parse(Boardgame.Element("item").Element("statistics").Element("ratings").Element("bayesaverage").Attribute("value").Value),
Rank = GetRanking(Boardgame.Element("item").Element("statistics").Element("ratings").Element("ranks")),
Publishers = (from p in Boardgame.Element("item").Elements("link") where p.Attribute("type").Value == "boardgamepublisher" select p.Attribute("value").Value).ToList(),
Designers = (from p in Boardgame.Element("item").Elements("link") where p.Attribute("type").Value == "boardgamedesigner" select p.Attribute("value").Value).ToList(),
Artists = (from p in Boardgame.Element("item").Elements("link") where p.Attribute("type").Value == "boardgameartist" select p.Attribute("value").Value).ToList(),
Comments = LoadComments(Boardgame.Element("item").Element("comments")),
PlayerPollResults = LoadPlayerPollResults(Boardgame.Element("item").Element("poll")),
IsExpansion = SetIsExpansion(Boardgame),
TotalComments = int.Parse(Boardgame.Element("item").Element("comments").Attribute("totalitems").Value)
};
return(gameCollection.FirstOrDefault());
}
catch (Exception ex)
{
return(null);
}
}
public async Task <BGGUser> LoadUserDetails(string username)
{
try
{
Uri teamDataURI = new Uri(string.Format(BASE_URL + "/user?name={0}", username));
XDocument xDoc = await ReadData(teamDataURI);
// LINQ to XML.
IEnumerable <BGGUser> users = from Boardgame in xDoc.Descendants("user")
select new BGGUser
{
Avatar = GetStringValue(Boardgame.Element("avatarlink"), "value"),
Username = username
};
return(users.FirstOrDefault());
}
catch (Exception ex)
{
return(new BGGUser());
}
}
public async Task <IEnumerable <SearchResult> > Search(string query)
{
try
{
Uri teamDataURI = new Uri(string.Format(BASE_URL + "/search?query={0}&type=boardgame", query));
XDocument xDoc = await ReadData(teamDataURI);
// LINQ to XML.
IEnumerable <SearchResult> gameCollection = from Boardgame in xDoc.Descendants("item")
select new SearchResult
{
Name = GetStringValue(Boardgame.Element("name"), "value"),
GameId = GetIntValue(Boardgame, "id")
};
return(gameCollection);
}
catch (Exception ex)
{
return(new List <SearchResult>());
}
}
