public async Task <IActionResult> Edit(TeamBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var group = await this.ts.GetGroupByName(model.Group.Name);
if (group == null)
{
group = new Group
{
Name = model.Group.Name
};
await this.ts.CreateGroup(group);
}
var team = this.mapper.Map <Team>(model);
if (team.GroupId != group.Id)
{
team.GroupId = group.Id;
}
await this.ts.UpdateTeam(team);
this.TempData["SuccessMsg"] = "Team has been edited Successfully!";
return(this.RedirectToAction("Index"));
}
public async Task <IActionResult> Update([FromBody] TeamBindingModel model)
{
var entity = await _repository.QueryableAll(x => x.Id == model.Id).Include(x => x.ParticipantTeams).FirstOrDefaultAsync();
if (entity == null)
{
return(BadRequest(new BadRequestResponseModel(ErrorTypes.BadRequest, ErrorMessages.ItemNotFound)));
}
// Update Participants
foreach (var item in model.Participants)
{
if (entity.ParticipantTeams.Any(x => x.TeamMemberId == item))
{
continue;
}
entity.ParticipantTeams.Add(new ParticipantTeam {
TeamId = entity.Id, TeamMemberId = item
});
}
var deletedParticipantTeams = entity.ParticipantTeams.Where(x => !model.Participants.Contains(x.TeamMemberId)).ToList();
deletedParticipantTeams.ForEach(x => entity.ParticipantTeams.Remove(x));
entity.Name = model.Name;
entity.Description = model.Description;
entity.UpdatedAt = DateTime.Now;
entity.UpdatedBy = UserId;
await _repository.UpdateAsync(entity);
return(Ok());
}
public ActionResult Create(TeamBindingModel bind)
{
if (ModelState.IsValid)
{
var team = Mapper.Map <TeamBindingModel, Team>(bind);
var country = this.db.Countries.Find(bind.CountryId);
team.Country = country;
var city = this.db.Cities.Find(bind.CityId);
team.City = city;
db.Teams.Add(team);
db.SaveChanges();
return(RedirectToAction("Index"));
}
var availableCountries = this.db.Countries.ToList();
var availableCountriesModel =
Mapper.Map <IEnumerable <Country>, IEnumerable <CountryBindingModel> >(availableCountries);
var availableCities = this.db.Cities.ToList();
var availableCitiesModel =
Mapper.Map <IEnumerable <City>, IEnumerable <CityBindingModel> >(availableCities);
var model = new TeamBindingModel
{
AvailableCountries = availableCountriesModel,
AvailableCities = availableCitiesModel
};
return(View(model));
}
public void Create_WithValidBindingModel_ShouldReturnOk()
{
//arrange
this.mockTeamRepository
.Setup(x => x.AddAsync(
It.IsAny <string>(),
It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(new Team());
var team = new TeamBindingModel
{
Name = "test name",
Members = Enumerable.Range(1, 2).Select(x => Guid.NewGuid())
};
//act
var response = this.testClient.PostAsJsonAsync("/api/teams", team).Result;
//assert
this.mockTeamRepository
.Verify(
x => x.AddAsync(
It.IsAny <string>(),
It.IsAny <IEnumerable <Guid> >()),
Times.Once());
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public async Task SaveTeam(TeamBindingModel model)
{
var team = this.Mapper.Map <Team>(model);
await this.DbContext.Teams.AddAsync(team);
await this.DbContext.SaveChangesAsync();
}
public async Task <IActionResult> Create([FromBody] TeamBindingModel model)
{
var entity = _mapper.Map <Team>(model);
entity.CreatedBy = UserId;
await _repository.AddAsync(entity);
return(Ok());
}
public async Task <IActionResult> Edit(int id, TeamBindingModel model)
{
await this.adminTeamsService.EditTeam(id, model);
this.TempData[AdminConstants.MessageType] = AdminConstants.Success;
this.TempData[AdminConstants.Message] = string.Format(AdminConstants.SuccessfullyEdit,
AdminConstants.Team);
return(RedirectToAction(AdminConstants.ActionDetails, new { id = id }));
}
public async Task <IActionResult> Create(TeamBindingModel model)
{
await this.adminTeamsService.SaveTeam(model);
this.TempData[AdminConstants.MessageType] = AdminConstants.Success;
this.TempData[AdminConstants.Message] = string.Format(AdminConstants.SuccessfullyAdd,
AdminConstants.Team);
return(RedirectToAction(nameof(Index)));
}
public async Task EditTeamAsync_WithNoValidId_ShouldThrowArgumentNullException()
{
var bindingModel = new TeamBindingModel
{
Name = string.Format(TestsConstants.EditTeam, 1),
LogoUrl = string.Format(TestsConstants.EditLogo, 1)
};
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() =>
this.service.EditTeam(2, bindingModel));
}
public async Task EditTeam(int id, TeamBindingModel model)
{
var team = await this.DbContext.Teams.FindAsync(id);
this.CheckIfTeamExist(team);
team.Name = model.Name;
team.LogoUrl = model.LogoUrl;
await this.DbContext.SaveChangesAsync();
}
public async Task GetTeamAsync_WithId_ShouldReturnTypeofTeamBindingModel()
{
var teamFromService = await this.service.GetTeam(1);
var bindingModelTest = new TeamBindingModel()
{
Name = string.Format(TestsConstants.Team, 1),
LogoUrl = string.Format(TestsConstants.Logo, 1)
};
Assert.IsInstanceOfType(teamFromService, typeof(TeamBindingModel));
}
public IActionResult Update([FromBody] TeamBindingModel teamBindingModel)
{
TeamAdapter._employeeService = _employeeService;
if (_teamService.Update(TeamAdapter.ToTeamModel(teamBindingModel)) > 0)
{
return(Ok(teamBindingModel));
}
else
{
return(BadRequest());
}
}
public IActionResult Create([FromBody] TeamBindingModel teamBindingModel)
{
TeamAdapter._employeeService = _employeeService;
if (_teamService.Create(TeamAdapter.ToTeamModel(teamBindingModel)) > 0)
{
return(Ok(teamBindingModel));
}
else
{
return(StatusCode(500));
}
}
public async Task GetTeamAsync_WithId_ShouldReturnThisTeam()
{
var teamFromService = await this.service.GetTeam(1);
var bindingModelTest = new TeamBindingModel()
{
Name = string.Format(TestsConstants.Team, 1),
LogoUrl = string.Format(TestsConstants.Logo, 1)
};
Assert.AreEqual(bindingModelTest.LogoUrl, teamFromService.LogoUrl);
Assert.AreEqual(bindingModelTest.Name, teamFromService.Name);
}
public async Task <Response <BaseDto> > AddTeamAsync(TeamBindingModel team)
{
Response <BaseDto> response = new Response <BaseDto>();
var teamToAdd = Mapper.Map <Team>(team);
var addedSuccessfuly = await _teamRepository.AddTeamAsync(teamToAdd);
if (!addedSuccessfuly)
{
response.Errors.Add("Wystapił problem przy dodawaniu drużyny, spróbuj ponownie później");
}
return(response);
}
public ActionResult CreateNew(TeamBindingModel team)
{
if (!ModelState.IsValid)
{
return(View("TeamForm", team));
}
var newTeam = _factory.CreateNewTeam(team);
_context.Teams.Add(newTeam);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddTeamAsync([FromBody] TeamBindingModel team)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelStateErrors()));
}
var result = await _teamService.AddTeamAsync(team);
if (result.ErrorOccurred)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task EditTeamAsync_WithId_ShouldEditCorrectly()
{
var bindingModel = new TeamBindingModel
{
Name = string.Format(TestsConstants.EditTeam, 1),
LogoUrl = string.Format(TestsConstants.EditLogo, 1)
};
await service.EditTeam(1, bindingModel);
var team = this.dbContext.Teams.SingleOrDefault(x => x.Id == 1);
Assert.AreEqual(1, team.Id);
Assert.AreEqual(string.Format(TestsConstants.EditTeam, 1), team.Name);
Assert.AreEqual(string.Format(TestsConstants.EditLogo, 1), team.LogoUrl);
}
public ActionResult Create()
{
var availableCountries = this.db.Countries.ToList();
var availableCountriesModel =
Mapper.Map <IEnumerable <Country>, IEnumerable <CountryBindingModel> >(availableCountries);
var availableCities = this.db.Cities.ToList();
var availableCitiesModel =
Mapper.Map <IEnumerable <City>, IEnumerable <CityBindingModel> >(availableCities);
var model = new TeamBindingModel
{
AvailableCountries = availableCountriesModel,
AvailableCities = availableCitiesModel
};
return(View(model));
}
public IHttpActionResult Create(TeamBindingModel teamDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var team = _factory.CreateNewTeam(teamDto);
_context.Teams.Add(team);
_context.SaveChanges();
var dto = _factory.FromTeamToDto(team);
return(Created(new Uri(Request.RequestUri + "/" + dto.Id), dto));
}
public static Team ToTeamModel(TeamBindingModel teamBindingModel)
{
List <Employee> teamMembers = new List <Employee>();
foreach (int MemberId in teamBindingModel.MemberIds)
{
teamMembers.Add(_employeeService.Get(MemberId));
}
Team team = new Team();
team.TeamId = teamBindingModel.Id;
team.LeaderId = teamBindingModel.LeaderId;
team.Leader = _employeeService.Get(teamBindingModel.LeaderId);
team.TeamName = teamBindingModel.TeamName;
team.Employees = teamMembers;
return(team);
}
public async Task <IActionResult> CreateTeam([FromBody] TeamBindingModel newTeam)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var team = await this.teamRepository.AddAsync(
newTeam.Name,
newTeam.Members);
if (team == null)
{
return(this.BadRequest());
}
return(this.Ok(team));
}
public async Task SaveTeamAsync_WithProperTeam_ShouldAddCorrectly()
{
var teamToRemove = this.dbContext.Teams.SingleOrDefault(x => x.Id == 1);
this.dbContext.Teams.Remove(teamToRemove);
this.dbContext.SaveChanges();
var teamModel = new TeamBindingModel
{
Name = string.Format(TestsConstants.Team, 1),
LogoUrl = string.Format(TestsConstants.Logo, 1),
};
await this.service.SaveTeam(teamModel);
Assert.AreEqual(1, this.dbContext.Teams.Count());
var team = this.dbContext.Teams.Last();
Assert.AreEqual(string.Format(TestsConstants.Team, 1), team.Name);
Assert.AreEqual(string.Format(TestsConstants.Logo, 1), team.LogoUrl);
}
public ActionResult Edit(TeamBindingModel model)
{
if (ModelState.IsValid)
{
var team = this.db.Teams.Find(model.Id);
team = Mapper.Map <TeamBindingModel, Team>(model);
this.db.Teams.AddOrUpdate(a => a.Id, team);
this.db.SaveChanges();
var country = this.db.Countries.Find(model.CountryId);
team = this.db.Teams.Find(model.Id);
team.Country = country;
this.db.Entry(team.Country).State = EntityState.Modified;
var city = this.db.Cities.Find(model.CityId);
team.City = city;
this.db.Entry(team.City).State = EntityState.Modified;
this.db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
/// <summary>
/// MapFromTeamTpDto new team based on dto
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public Team CreateNewTeam(TeamBindingModel dto)
{
Team team = new Team(dto.Name);
return(team);
}
