public async Task <IActionResult> Create(Teamdto team)
{
if (ModelState.IsValid)
{
var directory = Path.Combine(_hosting.WebRootPath, "Home", "images", "Teams");
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
if (team.TeamImage != null)
{
team.FileName = team.TeamImage.FileName;
using (var stream = new FileStream(Path.Combine(directory, team.FileName), FileMode.Create))
{
await team.TeamImage.CopyToAsync(stream);
}
}
var teamModel = _mapper.Map <Team>(team);
_context.Teams.Add(teamModel);
//var users = await _userManager.GetUserAsync(HttpContext.User);
//_context.ClubAdmins.Add(new ClubAdmin
//{
// TeamId = teamModel.TeamId,
// UserId = users.Id
//});
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Grounddto ground)
{
if (ModelState.IsValid)
{
//var directory = Path.Combine(_hosting.WebRootPath, "Home", "images", "Ground");
//if (!Directory.Exists(directory))
// Directory.CreateDirectory(directory);
//if (ground.GroundImage != null)
//{
// ground.FileName = ground.GroundImage.FileName;
// using (var stream = new FileStream(Path.Combine(directory, ground.FileName), FileMode.Create))
// {
// await ground.GroundImage.CopyToAsync(stream);
// }
//}
var users = await _userManager.GetUserAsync(HttpContext.User);
var groundModel = _mapper.Map <Ground>(ground);
//groundModel.UserId = users.Id;
_context.Ground.Add(groundModel);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Tournamentdto tournament)
{
if (ModelState.IsValid)
{
var directory = Path.Combine(_hosting.WebRootPath, "Home", "images", "Tournament");
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
if (tournament.TournamentImage != null)
{
tournament.FileName = tournament.TournamentImage.FileName;
using (var stream = new FileStream(Path.Combine(directory, tournament.FileName), FileMode.Create))
{
await tournament.TournamentImage.CopyToAsync(stream);
}
}
var users = await _userManager.GetUserAsync(HttpContext.User);
var tournamentModel = _mapper.Map <Tournament>(tournament);
tournamentModel.UserId = users.Id;
_context.Tournaments.Add(tournamentModel);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(MatchSeriesdto matchSeries)
{
if (ModelState.IsValid)
{
var directory = Path.Combine(_hosting.WebRootPath, "Home", "images", "Series");
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
if (matchSeries.SeriesImage != null)
{
matchSeries.FileName = matchSeries.SeriesImage.FileName;
using (var stream = new FileStream(Path.Combine(directory, matchSeries.FileName), FileMode.Create))
{
await matchSeries.SeriesImage.CopyToAsync(stream);
}
}
var users = await _userManager.GetUserAsync(HttpContext.User);
var matchSeriesModal = _mapper.Map <MatchSeries>(matchSeries);
matchSeriesModal.UserId = users.Id;
_context.MatchSeries.Add(matchSeriesModal);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(View(matchSeries));
}
public async Task <IActionResult> Create(Teamdto team)
{
if (ModelState.IsValid)
{
var form = Request.Form;
byte[] fileBytes = null;
if (team.TeamImage != null)
{
using (var stream = team.TeamImage.OpenReadStream())
{
fileBytes = ReadStream(stream);
}
}
team.TeamLogo = fileBytes ?? null;
var teamModel = _mapper.Map <Team>(team);
_context.Teams.Add(teamModel);
var users = await _userManager.GetUserAsync(HttpContext.User);
_context.ClubAdmins.Add(new ClubAdmin
{
TeamId = teamModel.TeamId,
UserId = users.Id
});
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> CreateSchedule([FromBody] MatchScheduledto matchSchedule)
{
if (ModelState.IsValid)
{
var model = _mapper.Map <MatchSchedule>(matchSchedule);
_context.MatchSchedule.Update(model);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Tournamentdto tournament)
{
if (ModelState.IsValid)
{
var users = await _userManager.GetUserAsync(HttpContext.User);
var tournamentModel = _mapper.Map <Tournament>(tournament);
tournamentModel.UserId = users.Id;
_context.Tournaments.Add(tournamentModel);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(MatchSeriesdto matchSeries)
{
if (ModelState.IsValid)
{
var users = await _userManager.GetUserAsync(HttpContext.User);
var matchSeriesModal = _mapper.Map <MatchSeries>(matchSeries);
matchSeriesModal.UserId = users.Id;
_context.MatchSeries.Add(matchSeriesModal);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(View(matchSeries));
}
public async Task <IActionResult> HomeTeamSave([FromForm] TeamMatchScoredto HomeTeamplayers, int teamId)
{
if (ModelState.IsValid)
{
var model = new PlayerScore();
model.Position = HomeTeamplayers.HomeTeamScoreCard.Position;
model.IsPlayedInning = HomeTeamplayers.HomeTeamScoreCard.IsPlayedInning;
model.PlayerId = HomeTeamplayers.HomeTeamScoreCard.PlayerId;
model.HowOutId = HomeTeamplayers.HomeTeamScoreCard.HowOutId;
model.BowlerId = HomeTeamplayers.HomeTeamScoreCard.Bowler == -1 ? null : HomeTeamplayers.HomeTeamScoreCard.Bowler;
model.MatchId = HomeTeamplayers.HomeTeamScoreCard.MatchId;
model.TeamId = HomeTeamplayers.HomeTeamScoreCard.TeamId;
model.Fielder = HomeTeamplayers.HomeTeamScoreCard.Fielder;
model.Bat_Runs = HomeTeamplayers.HomeTeamScoreCard.Bat_Runs;
model.Bat_Balls = HomeTeamplayers.HomeTeamScoreCard.Bat_Balls;
model.Four = HomeTeamplayers.HomeTeamScoreCard.Four;
model.Six = HomeTeamplayers.HomeTeamScoreCard.Six;
model.Ball_Runs = HomeTeamplayers.HomeTeamScoreCard.Ball_Runs;
model.Overs = HomeTeamplayers.HomeTeamScoreCard.Overs;
model.Wickets = HomeTeamplayers.HomeTeamScoreCard.Wickets;
model.Maiden = HomeTeamplayers.HomeTeamScoreCard.Maiden;
model.RunOut = HomeTeamplayers.HomeTeamScoreCard.RunOut;
model.Catches = HomeTeamplayers.HomeTeamScoreCard.Catches;
model.Stump = HomeTeamplayers.HomeTeamScoreCard.Stump;
_context.PlayerScores.Add(model);
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Playersdto player)
{
if (ModelState.IsValid)
{
//var form = Request.Form;
//byte[] fileBytes = null;
//if (player.PlayerImage != null)
//{
// using (var stream = player.PlayerImage.OpenReadStream())
// {
// fileBytes = ReadStream(stream);
// }
//}
var directory = Path.Combine(_hosting.WebRootPath, "Home", "images", "Players");
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
if (player.PlayerImage != null)
{
player.FileName = player.PlayerImage.FileName;
using (var stream = new FileStream(Path.Combine(directory, player.FileName), FileMode.Create))
{
await player.PlayerImage.CopyToAsync(stream);
}
}
//player.PlayerLogo = fileBytes ?? null;
_context.Players.Add(_mapper.Map <Player>(player));
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> HomeTeamSave([FromForm] TeamMatchScoredto HomeTeamplayers, int teamId)
{
if (ModelState.IsValid)
{
_context.AddRange(HomeTeamplayers.HomeTeamScoreCard.Select(i => new PlayerScore
{
Position = i.Position,
IsPlayedInning = i.IsPlayedInning,
PlayerId = i.PlayerId,
HowOutId = i.HowOutId,
Bowler = i.Bowler,
MatchId = i.MatchId,
TeamId = i.TeamId
}
));
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
// return RedirectToAction(nameof(Index), new { matchId = Matchplayers.Select(i => i.MatchId).First(), teamId });
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Playersdto player)
{
if (ModelState.IsValid)
{
var form = Request.Form;
byte[] fileBytes = null;
if (player.PlayerImage != null)
{
using (var stream = player.PlayerImage.OpenReadStream())
{
fileBytes = ReadStream(stream);
}
}
//var file = await FileHelpers.ProcessFormFile(player.PlayerImage, ModelState);
player.PlayerLogo = fileBytes ?? null;
_context.Players.Add(_mapper.Map <Player>(player));
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> Create(Matchdto match)
{
if (ModelState.IsValid)
{
var form = Request.Form;
byte[] fileBytes = null;
if (match.MatchImage != null)
{
using (var stream = match.MatchImage.OpenReadStream())
{
fileBytes = ReadStream(stream);
}
}
var users = await _userManager.GetUserAsync(HttpContext.User);
match.UserId = users.Id;
match.MatchLogo = fileBytes ?? null;
_context.Matches.Add(_mapper.Map <Match>(match));
await _context.SaveChangesAsync();
return(Json(ResponseHelper.Success()));
}
return(Json(ResponseHelper.UnSuccess()));
}
public async Task <IActionResult> PastRecordSave(PlayerPastRecorddto playerPastRecord)
{
if (ModelState.IsValid)
{
try
{
var model = _mapper.Map <PlayerPastRecord>(playerPastRecord);
_context.Update(model);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(new { Error = ex, Data = playerPastRecord, ModelState }));
}
return(Json(ResponseHelper.UpdateSuccess()));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Edit(AspUserdto model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (!string.IsNullOrEmpty(model.Password))
{
if (model.ConfirmPassword != model.Password)
{
ModelState.AddModelError(nameof(model.ConfirmPassword), "Confirm password does not match ");
}
var resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
await _userManager.ResetPasswordAsync(user, resetToken, model.Password);
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
user.PhoneNumber = model.PhoneNumber;
user.UserName = model.UserName;
await _userManager.UpdateAsync(user);
var team = new Team {
TeamId = model.TeamId.Value
};
_context.Attach(team);
team.UserId = model.Id;
await _context.SaveChangesAsync();
return(Json(ResponseHelper.UpdateSuccess()));
}
return(BadRequest(ModelState));
}
