public IActionResult Create(CreatePlayerViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
if (!_playerServices.CheckNameIsAvailable(model.PlayerName))
{
return(this.View());
}
var userid = this._userManager.GetUserId(this.User);
//ADD Default configuration
var player = this.mapper.Map <Player>(model);
player.AplicationUserId = userid;
player.NodeId = "1001";
player.Money = 1000;
player.PlanPlayers.Add(new PlanPlayer()
{
PlanId = 1
});
player.PlayerShips.Add(new PlayerShip()
{
ShipId = 1
});
_playerServices.Add(player);
return(this.View("Index", player));
}
public ActionResult Edit(int id, CreatePlayerViewModel vm)
{
Player player = CompositionRoot.DocumentSession.Load <Player>(id);
if (player == null)
{
throw new HttpException(404, "Player not found");
}
// prevent duplicates
Player[] duplicates = CompositionRoot.DocumentSession.Query <Player, PlayerSearch>().Where(x => x.Name == vm.Name).ToArray();
if (duplicates.Any(x => x.Id != player.Id))
{
ModelState.AddModelError("namn", "Namnet är redan registrerat");
}
if (!ModelState.IsValid)
{
return(View(vm));
}
player.SetName(vm.Name);
player.SetEmail(vm.Email);
player.SetStatus(vm.Status);
player.SetPersonalNumber(vm.PersonalNumber.GetValueOrDefault());
player.SetNickname(vm.Nickname);
HashSet <string> allowedRoles = new(
WebsiteRoles.UserGroup().Except(WebsiteRoles.PlayerGroup()).Select(x => x.Name));
player.SetRoles(vm.Roles.Where(x => allowedRoles.Contains(x)).ToArray());
return(RedirectToAction("Index"));
}
public ActionResult Create()
{
var teams = db.Teams.ToList();
List <SelectListItem> items = new List <SelectListItem>();
foreach (var team in teams)
{
var item = new SelectListItem
{
Value = team.Id.ToString(),
Text = team.Name
};
items.Add(item);
}
MultiSelectList teamsList = new MultiSelectList(items.OrderBy(i => i.Text), "Value", "Text");
CreatePlayerViewModel viewModel = new CreatePlayerViewModel {
Teams = teamsList
};
return(View(viewModel));
}
public ActionResult Create(CreatePlayerViewModel vm)
{
// prevent duplicates
bool isDuplicate = CompositionRoot.DocumentSession.Query <Player, PlayerSearch>().Any(x => x.Name == vm.Name);
if (isDuplicate)
{
ModelState.AddModelError("namn", "Namnet är redan registrerat");
}
if (!ModelState.IsValid)
{
return(View(vm));
}
Player player = new(
vm.Name,
vm.Email,
vm.Status,
vm.PersonalNumber.GetValueOrDefault(),
vm.Nickname,
vm.Roles);
CompositionRoot.DocumentSession.Store(player);
return(RedirectToAction("Index"));
}
public ActionResult Create(CreatePlayerViewModel player)
{
var newPlayer = new Player(player.Name);
Players.Add(newPlayer);
PlayersData.PersistPlayer(newPlayer);
return(Redirect("~/Players"));
}
public void CreatePlayer(CreatePlayerViewModel player)
{
Player dbPlayer = new Player
{
FirstName = player.FirstName,
LastName = player.LastName,
TeamId = player.SelectedTeamId.Value
};
_db.Players.Add(dbPlayer);
_db.SaveChanges();
}
public ActionResult CreatePlayer(CreatePlayerViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
_fussballRepository.CreatePlayer(new Player {
Name = vm.Name, Initials = vm.Initials
});
_unitOfWork.Save();
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "Name, TeamIds")] CreatePlayerViewModel model)
{
if (ModelState.IsValid)
{
// Instantiate our new player with only the Id and Name properties
Player player = new Player
{
PlayerId = Guid.NewGuid(),
Name = model.Name
};
if (model.TeamIds != null)
{
foreach (var id in model.TeamIds)
{
// Convert the id to a Guid from a string
var teamId = Guid.Parse(id);
// Retrieve team from database...
var team = db.Teams.Find(c => c.TeamId == teamId);
// ... and add it to the player's Team collection
try
{
player.Teams.Add(team);
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Players", "Index")));
}
}
}
// Add new Player to db & save changes
try
{
db.Players.Add(player);
//db.SaveChanges();
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Players", "Index")));
}
// If successful, return
return(RedirectToAction("Details", new { id = player.PlayerId }));
}
else
{
ModelState.AddModelError("", "Something failed.");
return(View(model));
}
}
// GET: Players/Create
public ActionResult Create()
{
var teams = db.Teams.ToList();
/*
* OPTION 1 : THE LONG WAY
*
* Description: Intended to show the process of creating the MultiSelectList.
* Option 2 is much quicker.
*/
//Initialize the empty list of SelecListItems
List <SelectListItem> items = new List <SelectListItem>();
// Loop over each team in our teams List...
foreach (var team in teams)
{
// ... and instantiate a new SelectListItem for each one...
var item = new SelectListItem
{
Value = team.TeamId.ToString(),
Text = team.Name
};
// ... then add to our items List
items.Add(item);
}
;
// Instantiate our MultiSelect list, adding in our items list and ordering by the Text field (i.e. Team name)
MultiSelectList teamsList = new MultiSelectList(items.OrderBy(i => i.Text), "Value", "Text");
/*
* OPTION 2: THE SHORT WAY
*
* Description: Directly instantiates the MultiSelectList without all of the preamble.
* Uncomment the below line and comment out the above instantiation of teamsList to test Option 2.
*/
//MultiSelectList teamsList = new MultiSelectList(db.Teams.ToList().OrderBy(i => i.Name), "TeamId", "Name");
// Instantiate our CreatePlayerViewModel and set the Teams property to our teamslist MultiSelectList...
CreatePlayerViewModel model = new CreatePlayerViewModel {
Teams = teamsList
};
// ...and return it in our View.
return(View(model));
}
public HttpResponse Add(CreatePlayerViewModel model)
{
if (!User.IsAuthenticated)
{
return(Redirect("/Users/Login"));
}
var checkForErrors = playerService.CreatePlayer(model, this.User.Id);
if (checkForErrors.Count != 0)
{
return(Error(checkForErrors));
}
return(Redirect("/Players/All"));
}
public async Task <IActionResult> PostAsync([FromBody] CreatePlayerViewModel player)
{
if (ModelState.IsValid)
{
var newPlayer = Mapper.Map <PlayerDTO>(player);
var createdPlayerId = await _fmService.AddNewPlayerAsync(newPlayer);
if (createdPlayerId > 0)
{
return(Created($"api/players/{createdPlayerId}",
Mapper.Map <CreatePlayerViewModel>(newPlayer)));
}
}
return(BadRequest("Failed to add new player"));
}
public ActionResult Create([Bind(Include = "Name, TeamIds")] CreatePlayerViewModel viewModel)
{
if (ModelState.IsValid)
{
Player player = new Player
{
Id = Guid.NewGuid(),
Name = viewModel.Name
};
if (viewModel.TeamIds != null)
{
foreach (var id in viewModel.TeamIds)
{
var teamId = Guid.Parse(id);
var team = db.Teams.Find(teamId);
try
{
player.Teams.Add(team);
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Players", "Index")));
}
}
}
try
{
db.Players.Add(player);
db.SaveChanges();
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Players", "Index")));
}
return(RedirectToAction("Details", new { id = player.Id }));
}
else
{
ModelState.AddModelError("", "Something failed.");
return(View(viewModel));
}
}
public List <string> CreatePlayer(CreatePlayerViewModel model, string userId)
{
ICollection <string> errorsModel = this.Validator.ValidateModel(model);
if (this.PlayerAlreadyExist(model.FullName))
{
errorsModel.Add("Player with That Name Already Exists");
}
if (string.IsNullOrWhiteSpace(model.Endurance) ||
(int.Parse(model.Endurance) < 0 && int.Parse(model.Endurance) > 10))
{
errorsModel.Add("Endurance should be beatween 0 and 10");
}
if (string.IsNullOrWhiteSpace(model.Speed) ||
(int.Parse(model.Speed) < 0 && int.Parse(model.Speed) > 10))
{
errorsModel.Add("Speed should be beatween 0 and 10");
}
if (errorsModel.ToList().Count != 0)
{
return(errorsModel.ToList());
}
var player = new Player
{
FullName = model.FullName,
Speed = (byte)int.Parse(model.Speed),
Endurance = (byte)int.Parse(model.Endurance),
ImageUrl = model.ImageUrl,
Description = model.Description,
Position = model.Position,
};
this.Data.Players.Add(player);
this.Data.SaveChanges();
return(errorsModel.ToList());
}
public async Task <ActionResult> CreatePlayer(CreatePlayerViewModel player)
{
int newPlayerId = -1;
if (string.IsNullOrEmpty(player.Name))
{
return(CreateError("Spelare kunde inte skapas", "Spelaren måste ha ett namn."));
}
try
{
Player playerToStore = new Player()
{
Name = player.Name
};
newPlayerId = _playerRepository.AddPlayerToDb(playerToStore);
if (newPlayerId < 0)
{
return(CreateError("Spelaren kunde inte lagras i databasen", ""));
}
}
catch
{
return(CreateError("Spelaren kunde inte lagras i databasen", ""));
}
if (player.ImageUpload != null)
{
try
{
Image bitmap = Image.FromStream(player.ImageUpload.InputStream);
ImageFormat imageFormat = null;
string imageFormatAsString = player.ImageUpload.ContentType.Split('/').Last();
switch (imageFormatAsString)
{
case "png":
imageFormat = ImageFormat.Png;
break;
case "jpg":
case "jpeg":
imageFormat = ImageFormat.Jpeg;
break;
case "gif":
imageFormat = ImageFormat.Gif;
break;
case "bmp":
imageFormat = ImageFormat.Bmp;
break;
default:
break;
}
double ratio = (double)bitmap.Width / (double)bitmap.Height;
bitmap = ratio >= 0 ? ImageProcessing.ResizeImage(bitmap, 150, (int)(150 / ratio)) : ImageProcessing.ResizeImage(bitmap, (int)(150 / ratio), 150);
await FileStorageDA.UploadImage(bitmap, newPlayerId + "_profileImage." + imageFormatAsString);
}
catch (Exception e)
{
return(CreateError("Bilden kunde inte sparas", "Spelare är sparad med bilden kunde inte lagras inte sparas. Vänligen kontrollera att bilden var i ett vanligt bildformat(jpg, png, gif eller bmp."));
}
}
return(View("PlayerCreated", player));
}
public ActionResult CreatePlayerPartial()
{
var player = new CreatePlayerViewModel();
return(PartialView(player));
}
public CreatePlayerView(CreatePlayerViewModel initLoginViewModel)
{
InitializeComponent();
DataContext = initLoginViewModel;
}
public CreatePlayerPage()
{
InitializeComponent();
DataContext = new CreatePlayerViewModel();
}
