public ActionResult <TeamDto> CreateTeam(Guid personId, Guid projectId, [FromBody] CreateTeamDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_db.Person.BelongsToUser(personId, HttpContext))
{
return(Forbid());
}
if (_db.Participation.GetRole(personId, projectId)?.CalendarWrite != true)
{
return(Forbid());
}
var team = _mapper.Map <Team>(dto);
team.ProjectId = projectId;
_db.Team.Create(team);
_db.Save();
return(Ok(_mapper.Map <TeamDto>(team)));
}
catch (Exception e)
{
_logger.LogError($"ERROR in CreateTeam: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
/// <summary>
/// Create a new team.
/// </summary>
/// <param name="teamToCreate">A Team to create.</param>
public Team Create(CreateTeamDto teamToCreate)
{
_authService.CheckAccess(AuthOperations.Teams.Create);
if (teamToCreate.Captain == null)
{
throw new EntityInvariantViolationException("Captain can not be null");
}
ThrowExceptionIfTeamWithSuchNameExists(teamToCreate.Name);
var captain = GetPlayerById(teamToCreate.Captain.Id);
if (captain == null)
{
throw new MissingEntityException(ServiceResources.ExceptionMessages.PlayerNotFound, teamToCreate.Captain.Id);
}
// Check if captain in teamToCreate is captain of another team
var existTeam = GetTeamLedByCaptain(captain.Id);
VerifyExistingTeamOrThrow(existTeam);
return(_teamRepository.Add(teamToCreate));
}
private async Task <ResponseMessagesDto> CreateTeamAsync(CreateTeamDto model)
{
var result = await _repository.InsertAsync(new Team()
{
Address = model.Address,
Zone = model.Zone,
Name = model.Name,
TenantId = model.TenantId
});
await UnitOfWorkManager.Current.SaveChangesAsync();
if (result.Id != 0)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyInserted,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.InsertFailure,
Success = false,
Error = true,
});
}
private async Task <ResponseMessagesDto> UpdateTeamAsync(CreateTeamDto model)
{
var result = await _repository.UpdateAsync(new Team()
{
Id = model.Id,
Address = model.Address,
Name = model.Name,
Zone = model.Zone,
TenantId = model.TenantId
});
if (result != null)
{
return(new ResponseMessagesDto()
{
Id = result.Id,
SuccessMessage = AppConsts.SuccessfullyUpdated,
Success = true,
Error = false,
});
}
return(new ResponseMessagesDto()
{
Id = 0,
ErrorMessage = AppConsts.UpdateFailure,
Success = false,
Error = true,
});
}
public async Task <IActionResult> Create([FromBody] CreateTeamDto teamDto)
{
if (teamDto == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var mappedTeam = Mapper.Map <Teams>(teamDto);
await _team.Create(teamDto);
//
if (!await _team.Save())
{
return(StatusCode(500, "Server Error, Something went wrong with our server"));
}
var createdUser = Mapper.Map <TeamDto>(mappedTeam);
return(CreatedAtRoute("GetTeam", new { id = createdUser.Id }, createdUser));
}
else
{
return(BadRequest(ModelState));
}
}
public Team Add(CreateTeamDto teamToCreate)
{
var players = teamToCreate.Roster.Select(x => x.Id);
var roster = _unitOfWork.Context.Players
.Where(p => players.Contains(p.Id)).ToList();
var newTeam = new TeamEntity {
Name = teamToCreate.Name,
Coach = teamToCreate.Coach,
CaptainId = teamToCreate.Captain.Id,
Achievements = teamToCreate.Achievements,
Players = roster
};
if (!_dbStorageSpecification.IsSatisfiedBy(newTeam))
{
throw new InvalidEntityException();
}
_dalTeams.Add(newTeam);
_unitOfWork.Commit();
return(new Team(
newTeam.Id,
newTeam.Name,
newTeam.Coach,
newTeam.Achievements,
new PlayerId(newTeam.CaptainId),
teamToCreate.Roster.ToList()
));
}
public async Task CreateTeam(CreateTeamDto teamDto)
{
try
{
Team t = new Team
{
Name = teamDto.Name,
ShortDescription = teamDto.Description,
OccupationFilter = teamDto.OccupationFilter,
AgeRange = teamDto.Range,
Identity = Guid.NewGuid(),
IsClosed = false,
TrackingState = TrackingState.Added
};
InsertMemberAsCreator(t, teamDto.ProfileId);
InsertOccupations(teamDto, t);
_teamService.ApplyChanges(t);
await _unitOfWork.SaveChangesAsync();
OnTeamCreated(new TeamCreatedArgs(t));
}
catch (Exception e)
{
OnCreationFaild(new TeamCreationFailedException("There was an error creating the team. Try again.", e, teamDto));
}
}
public async Task Create(CreateTeamDto team)
{
await _context.Teams.AddAsync(new Teams()
{
Description = team.Description,
Name = team.Name,
ProjectId = team.ProjectId,
});
}
public CreateTeamDtoBuilder()
{
_team = new CreateTeamDto {
Name = "Name",
Coach = "Coach",
Achievements = "Achievements",
Captain = new PlayerId(1),
Roster = new List <PlayerId>()
};
}
public async Task <ResponseMessagesDto> CreateOrEditAsync(CreateTeamDto model)
{
ResponseMessagesDto result;
if (model.Id == 0)
{
result = await CreateTeamAsync(model);
}
else
{
result = await UpdateTeamAsync(model);
}
return(result);
}
private void InsertOccupations(CreateTeamDto teamDto, Team t)
{
if (!teamDto.OccupationFilter)
{
return;
}
foreach (var ocpId in teamDto.OccupationIds)
{
t.AllowedOccupations.Add(new TeamOccupations
{
Team = t,
OccupationId = ocpId,
TrackingState = TrackingState.Added
});
}
}
public async Task <TeamDto> CreateTeam(CreateTeamDto createTeamDto)
{
if (false == IsModelValid(createTeamDto, out string issues))
{
throw new ArgumentException($"Team model is not valid. Issues: {issues}");
}
var teamToCreate = _mapper.Map <CreateTeamDto, TeamModel>(createTeamDto);
var createdTeam = await _context.Teams.AddAsync(teamToCreate);
await _context.SaveChangesAsync();
var teamDto = _mapper.Map <TeamModel, TeamDto>(createdTeam.Entity);
return(teamDto);
}
public IActionResult Create(CreateTeamDto model)
{
if (ModelState.IsValid)
{
model.AppUserId = GetLoggedUser().Id;
var teamEntity = _mapper.Map <TeamEntity>(model);
_teamService.Add(teamEntity);
_teamPlayersService.Add(new TeamPlayersEntity
{
AppUserId = model.AppUserId,
TeamId = teamEntity.Id
});
return(RedirectToAction("Index"));
}
return(View(model));
}
public void WhenIExecuteCreateTeam()
{
try
{
var teamDto = new CreateTeamDto {
Name = _teamName,
Coach = _coach,
Achievements = _achievements,
Captain = _captain,
Roster = _playerList
};
_team = _teamService.Create(teamDto);
_newTeamId = _team.Id;
}
catch (Exception ex)
{
_exception = ex;
}
}
public string Execute(string[] data)
{
if (!Validation.CheckLength(3, data) && !Validation.CheckLength(2, data))
{
return(InvalidLength);
}
if (Session.User == null)
{
return(NoUser);
}
var dto = new CreateTeamDto
{
Name = data[0],
Acronym = data[1],
};
if (data.Length > 2)
{
dto.Description = data[2];
}
if (teamService.Exists(dto.Name))
{
return(String.Format(TeamExists, dto.Name));
}
if (!Validation.ValidateAcronym(dto.Acronym))
{
return(InvalidAcronym);
}
if (!Validation.IsValid(dto))
{
return(InvalidDetails);
}
teamService.CreateTeam(dto.Name, dto.Acronym, dto.Description, Session.User.Username);
return(String.Format(SuccessMessage, dto.Name));
}
public async Task <TeamDto> CreateTeamAsync(int userId, CreateTeamDto dto)
{
if (dto == null)
{
throw new ArgumentNullException();
}
if (await this.repository.TeamNameExistsAsync(dto.Name).ConfigureAwait(false))
{
throw new BadRequestException("Team name already exists.");
}
var newTeam = new TeamDto
{
Id = await this.repository.CreateTeamAsync(dto.Name, dto.Zip).ConfigureAwait(false),
Name = dto.Name,
Zip = dto.Zip,
};
await this.repository.AddUserToTeamAsync(userId, newTeam.Id).ConfigureAwait(false);
return(newTeam);
}
public async Task <object> CreateTeam([FromBody] CreateTeamDto model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.Advanced == model.Beginner)
{
return(BadRequest(new { message = "Advanced and Beginner must not be the same" }));
}
var team = new Team()
{
Name = model.Name,
Advanced = model.Advanced,
Beginner = model.Beginner
};
var dbTeam = await _dbContext.Teams.AddAsync(team);
_dbContext.Problems
.Where(x => x.Beginner == model.Beginner)
.Where(x => x.Advanced == model.Advanced)
.ToList()
.ForEach(x => _dbContext.TeamProblems.Add(new TeamProblems()
{
Team = dbTeam.Entity, Problem = x, MarkedForJudging = false
}));
await _dbContext.SaveChangesAsync();
return(Ok(dbTeam.Entity));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private void MockTeamRepositoryAddToThrow(CreateTeamDto testTeam, Exception exception) => _teamRepositoryMock.Setup(tr => tr.Add(It.Is <CreateTeamDto>(dto => CreateTeamDtosAreEqual(dto, testTeam)))) .Throws(exception);
public static TeamModel ToTeamModel(this IMapper mapper, CreateTeamDto createTeamDto)
{
var teamModel = mapper.Map <CreateTeamDto, TeamModel>(createTeamDto);
return(teamModel);
}
public TeamCreationFailedException(Exception e, CreateTeamDto data)
{
}
public TeamCreationFailedException(string displayMessage, Exception e, CreateTeamDto data) : base(displayMessage)
{
}
private bool IsModelValid(CreateTeamDto createTeamDto, out string issues)
{
issues = "";
return(true);
}
private bool CreateTeamDtosAreEqual(CreateTeamDto x, CreateTeamDto y)
{
return(new CreateTeamDtoComparer().Compare(x, y) == 0);
}
private void VerifyCreateTeam(CreateTeamDto team, Times times)
{
_teamRepositoryMock.Verify(tr => tr.Add(It.Is <CreateTeamDto>(t => CreateTeamDtosAreEqual(t, team))), times);
}
public async Task <ObjectResult> CreateTeam(int userId, [FromBody] CreateTeamDto teamDto)
{
return(new OkObjectResult(await this.teamsService.CreateTeamAsync(userId, teamDto)));
}
public string Execute(params string[] args)
{
string result = default(string);
try
{
if (!Validate.ArgsCountValidate(this.expectedArgs[0], args) && !Validate.ArgsCountValidate(this.expectedArgs[1], args))
{
throw new FormatException(Constants.FormatException);
}
string name = args[0];
string acronym = args[1];
string description = default(string);
if (args.Length == 3)
{
description = args[2];
}
// Check if team exists
if (this.teamService.TeamExists(name))
{
throw new ArgumentException(string.Format(TeamExists, name));
}
// Create Do and validate properties
CreateTeamDto teamDto = new CreateTeamDto
{
Name = name,
Acronym = acronym,
Description = description
};
List <ValidationResult> validationResult = Validate.EntityValidator(teamDto);
if (validationResult != null)
{
result = validationResult.First().ErrorMessage;
}
// Chack if there is any logged in user
if (UserSession.LoggedInUser == null)
{
throw new InvalidOperationException(Constants.UserIsNotLoggedIn);
}
// Map to model
Team newTeam = Mapper.Map <Team>(teamDto);
newTeam.Creator = UserSession.LoggedInUser;
this.teamService.CreateTeam(newTeam);
result = string.Format(Success, newTeam.Name);
}
catch (Exception e)
{
result = e.Message;
}
return(result);
}
