public virtual async Task <ActionResult> Create(StadiumModel viewModel)
{
ViewBag.City = CList();
if (ModelState.IsValid)
{
if (!_Stadium.IsExist(viewModel.Name))
{
var item = new StadiumModel
{
City = viewModel.City,
CityID = viewModel.CityID,
IsEnabled = viewModel.IsEnabled,
Name = viewModel.Name
};
_Stadium.Add(viewModel);
await _uow.SaveChangesAsync();
return(View());
}
else
{
ViewBag.Message = "عنوان وارد شده تکراری است.";
return(View());
}
}
else
{
return(View());
}
}
public IActionResult EditPage(int id)
{
StadiumModel stadium = null;
using (var db = new BL())
{
var stadiums = Mapper.Map <List <StadiumModel> >(db.GetStadiums());
foreach (StadiumModel model in stadiums)
{
if (model.Id == id)
{
stadium = model;
break;
}
}
}
if (stadium != null)
{
currentEditionID = stadium.Id;
ViewData["StadiumPlaces"] = stadium.Places;
ViewData["StadiumCost"] = stadium.Cost;
}
return(View());
}
public void Edit(int ID, StadiumModel viewModel)
{
Stadium selectedlst = _Stadium.Find(ID);
selectedlst.City = viewModel.City;
selectedlst.CityID = viewModel.CityID;
selectedlst.Name = viewModel.Name;
selectedlst.IsEnabled = viewModel.IsEnabled;
selectedlst.UpdatedOn = DateTime.Now;
}
public HttpResponseMessage Stadiums(StadiumModel stadium)
{
int id = UoW.StadiumRepository.AddStadium(new Stadium
{
Name = stadium.Name,
Address = stadium.Address
});
return(Request.CreateResponse(HttpStatusCode.OK, id));
}
public IActionResult Delete(int StadiumID)
{
StadiumModel StadiumDetails = _StadiumServices.GetStadiumDetails(StadiumID);
if (StadiumDetails != null)
{
_StadiumServices.DeleteStadium(StadiumID);
return(new OkResult());
}
return(NotFound());
}
public async override Task SetDataFromServer(UpdateType crud)
{
if (crud == UpdateType.Update)
{
stadium = await stadiumInteractor.GetEntityById(Url, "Error during getting stadium", EntityId);
}
await Task.FromResult <object>(null);
SetTableViewModel();
}
public void Test_Put_Return_OkResult()
{
//Arrange
var controller = new StadiumController(stadiumService);
var request = new StadiumModel {
StadiumID = 1, StadiumName = "capetown"
};;
//Act
var data = controller.Put(1, request);
//Assert
Assert.IsType <OkResult>(data);
}
public void Add(StadiumModel viewModel)
{
var lst = new Stadium
{
Name = viewModel.Name,
City = viewModel.City,
CityID = viewModel.CityID,
IsDeleted = false,
IsEnabled = true
};
_Stadium.Add(lst);
}
public async Task Edit(StadiumModel stadium)
{
await repository.Update(new KadabraStadium()
{
Id = stadium.Id,
Description = stadium.Description,
Name = stadium.Name,
CountryId = stadium.CountryId,
Capacity = stadium.Capacity
});
await repository.Save();
}
public IActionResult AddStadium(int places, int costs)
{
StadiumModel stadium = new StadiumModel()
{
Places = places,
Cost = costs
};
using (var db = new BL())
db.AddStadium(Mapper.Map <StadiumBL>(stadium));
return(Redirect("~/Home/Index"));
}
public void Test_Post_Return_OkResult()
{
//Arrange
var controller = new StadiumController(stadiumService);
var request = new StadiumModel {
StadiumID = 1, StadiumName = "Centurion"
};
//Act
var data = controller.Post(request);
//Assert
Assert.IsType <OkObjectResult>(data);
}
public ActionResult Edit(int?ID)
{
if (ID == null)
{
return(RedirectToAction("Index"));
}
else
{
ViewBag.City = CList();
StadiumModel model = _Stadium.GetDetail(ID.Value);
return(View(model));
}
}
public async override Task GetEntitiesFromServer()
{
List <Task> tasks = new List <Task>();
Task <List <StadiumModel> > entitiesTask = interactor.GetEntities("api/floorball/stadiums", "Error during getting stadiums");
tasks.Add(entitiesTask);
/*Task<List<LeagueModel>> leaguesTask = interactor.GetEntities<LeagueModel>("api/floorball/leagues", "Error during getting leagues");
* tasks.Add(leaguesTask);
*
* Task<List<TeamModel>> teamsTask = interactor.GetEntities<TeamModel>("api/floorball/teams", "Error during getting teams");
* tasks.Add(teamsTask);*/
//Task<Dictionary<int, List<int>>> playersAndTeamsTask = interactor.GetEntityMappings("api/floorball/players/teams", "Error during getting teams for player");
await Task.WhenAll(tasks);
var entities = entitiesTask.Result;
/*var leagues = leaguesTask.Result;
* var teams = teamsTask.Result;*/
StadiumModel prevEntity = null;
List <SearchCell> searchList = new List <SearchCell>();
foreach (var entity in entities.OrderBy(e => e.Name))
{
if (prevEntity == null || entity.Name != prevEntity.Name)
{
SearchModel.Add(new List <SearchCell>());
Titles.Add(new SearchTitle {
MainTitle = "", Subtitle = ""
});
}
SearchModel.Last().Add(new SearchCell
{
Id = entity.Id,
Title = entity.Name,
Subtitle = entity.Address,
RightDetail = ""
});
prevEntity = entity;
}
FilteredSearchModel = new List <List <SearchCell> >(SearchModel);
FilteredTitles = new List <SearchTitle>(Titles);
}
public IActionResult SaveChanges(int places, int costs)
{
StadiumModel stadium = new StadiumModel()
{
Id = currentEditionID,
Places = places,
Cost = costs
};
using (var db = new BL())
db.UpdateStadium(Mapper.Map <StadiumBL>(stadium));
return(Redirect("~/Home/Index"));
}
public ActionResult Add(StadiumModel model)
{
if (Request.Cookies["user"] == null)
{
return(RedirectToAction("Login", "User"));
}
string username = Logged_username();
var dal = new Stadium_services();
MemoryStream target = new MemoryStream();
model.Image.InputStream.CopyTo(target);
model.Stadium.Picture = target.ToArray();
dal.New_stadium(model.Stadium, username);
return(RedirectToAction("Add", "Team"));
}
public IActionResult Post(StadiumModel Stadium)
{
bool Stadiumexist = _StadiumServices.GetStadiumsList().Any(x => x.Value.StadiumName == Stadium.StadiumName);
if (!Stadiumexist)
{
using (var scope = new TransactionScope())
{
_StadiumServices.AddStadium(Stadium);
scope.Complete();
return(CreatedAtAction(nameof(Get), new { id = Stadium.StadiumID }, Stadium));
}
}
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Stadium already exist" }));
}
public IActionResult Put(int StadiumID, StadiumModel Stadium)
{
StadiumModel StadiumDetails = _StadiumServices.GetStadiumDetails(StadiumID);
if (StadiumDetails != null)
{
using (var scope = new TransactionScope())
{
Stadium.StadiumID = StadiumID;
_StadiumServices.UpdateStadiumDetails(Stadium);
scope.Complete();
return(new OkResult());
}
}
return(NotFound());
}
public async Task <IHttpActionResult> EditStadium(StadiumModel stadium)
{
if (!ModelState.IsValid)
{
return(InternalServerError());
}
try
{
await services.Edit(stadium);
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <ActionResult> SaveStadium(StadiumModel stadium)
{
if (ModelState.IsValid)
{
await stadiumService.Edit(stadium);
return(RedirectToAction("Index"));
}
else
{
StadiumModelWithCountries model = await stadiumService.GetStadiumWithCountries(new StadiumIdModel()
{
Id = stadium.Id
});
return(View("Edit", model));
}
}
public virtual async Task <ActionResult> Edit(int ID, StadiumModel viewModel)
{
ViewBag.City = CList();
if (ModelState.IsValid)
{
if (!_Stadium.IsExist(viewModel.Name, ID))
{
_Stadium.Edit(ID, viewModel);
await _uow.SaveChangesAsync();
}
else
{
ViewBag.Message = "عنوان وارد شده در سیستم موجود است.";
return(View());
}
}
return(View());
}
/// <summary>
/// Update Stadium
/// </summary>
/// <param name="Stadium"></param>
public void UpdateStadiumDetails(StadiumModel Stadium)
{
_StadiumContext.Remove(Stadium.StadiumID);
_StadiumContext.Add(Stadium.StadiumID, Stadium);
}
/// <summary>
/// Add Stadium
/// </summary>
/// <param name="Stadium"></param>
public void AddStadium(StadiumModel Stadium)
{
Stadium.StadiumID = _StadiumContext.Count + 1;
_StadiumContext.Add(Stadium.StadiumID, Stadium);
}
public override void ClearModel()
{
stadium = null;
Model.Clear();
}
protected override void Validate()
{
stadium = new StadiumModel()
{
};
}
public IActionResult AddGame(string date, int spectators, int place, int[] players, string result)
{
List <PlayerModel> chosenPlayers = new List <PlayerModel>();
StadiumModel chosenPlace = null;
Models.Result chosenResult = 0;
using (var db = new BL())
{
List <PlayerModel> listPlayers = Mapper.Map <List <PlayerModel> >(db.GetPlayers());
// Forming the list of players from DataBase
for (int i = 0; i < players.Length; i++)
{
foreach (PlayerModel playerModel in listPlayers)
{
if (playerModel.Id == players[i])
{
chosenPlayers.Add(playerModel);
break;
}
}
}
// Getting the stadium by id from DataBase
foreach (StadiumModel model in Mapper.Map <List <StadiumModel> >(db.GetStadiums()))
{
if (model.Id == place)
{
chosenPlace = model;
break;
}
}
// Determining the result of the game by input string
switch (result)
{
case "Won":
chosenResult = Models.Result.Won;
break;
case "Failed":
chosenResult = Models.Result.Failed;
break;
case "Noone":
chosenResult = Models.Result.Noone;
break;
case "NotPlayed":
chosenResult = Models.Result.NotPlayed;
break;
}
// Changing state of involved players
foreach (PlayerModel player in chosenPlayers)
{
player.IsInGame = true;
db.UpdatePlayer(Mapper.Map <PlayerBL>(player));
}
;
// Forming game to DataBase
GameModel game = new GameModel()
{
Players = chosenPlayers,
Spectators = spectators,
Date = date,
Place = chosenPlace,
GameResult = chosenResult,
};
db.AddGame(Mapper.Map <GameBL>(game));
}
return(Redirect("~/Home/Index"));
}
public async Task Edit(StadiumModel stadium)
{
HttpResponseMessage response = await apiClient.PostAsJsonAsync("Kadabra/Stadium/EditStadium", stadium);
response.EnsureSuccessStatusCode();
}
