public async Task <TeamViewModel> Handle(AddTeamCommand addTeamCommand, CancellationToken cancellationToken) => await Task.Run(() =>
{
return(ExecuteAsync <TeamViewModel>(async response =>
{
var playersToAdd = new List <Player>();
var teamToAdd = new Team
{
Name = addTeamCommand.Name,
Longitude = addTeamCommand.Longitude,
Latitude = addTeamCommand.Latitude,
Players = playersToAdd
};
var addedTeam = await _teamRepository.AddAsync(teamToAdd);
foreach (var playerId in addTeamCommand.PlayerIds)
{
var player = await _playerRepository.GetPlayerByIdAsync(playerId);
player.Team = addedTeam;
await _playerRepository.UpdateAsync(player);
}
var updatedTeam = await _teamRepository.UpdateAsync(addedTeam);
var teamDto = _mapper.Map <TeamLookupModel>(addedTeam);
response.TeamLookupModel = teamDto;
}));
});
public async Task <ActionResult <Team> > PostTeam(TeamModel model)
{
try
{
var location = _linkGenerator.GetPathByAction("GetTeam", "Teams", new { id = -1 });
if (string.IsNullOrWhiteSpace(location))
{
return(BadRequest("Could not use ID"));
}
var team = _mapper.Map <Team>(model);
await _teamRepository.AddAsync(team);
if (await _sharedRepository.SaveChangesAsync() > 0)
{
return(Created(location, _mapper.Map <TeamModel>(team)));
}
return(BadRequest());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, Settings.DatabaseFailureString));
}
}
public async Task <bool> Handle(CreateTeamCommand request, CancellationToken cancellationToken)
{
var team = new Team(request.Name, string.Empty, TimeHelper.ConvertDataTimeToLong(DateTime.Now), request.Introduction, request.CreatePerson);
await _teamRepository.AddAsync(team);
return(await _teamRepository.UnitOfWork.SaveEntitiesAsync());
}
public async Task <Guid> Handle(CreateTeamCommand request, CancellationToken cancellationToken)
{
var team = Team.CreateNew(request.Name, request.Description, request.Logo, request.Manager, request.League,
request.Country, request.FormedYear, request.Facebook, request.Instagram, request.Stadium, request.ExternalId);
await _teamRepository.AddAsync(team);
return(team.Id.Value);
}
public async Task TeamRepository_AddTeam_Added_NotFail_Test()
{
var context = new MyCompanyContext();
int expected = context.Teams.Count() + 1;
var employeeId = context.Employees.FirstOrDefault().EmployeeId;
var teamId = context.Teams.Select(e => e.TeamId).Max() + 1;
var Team = new Team()
{
TeamId = teamId,
ManagerId = employeeId,
};
await target.AddAsync(Team);
int actual = context.Teams.Count();
Assert.AreEqual(expected, actual);
}
public async Task <IActionResult> Create([FromBody] DTO.Team.Input.Team team)
{
var teamResult = await _teamRepository.AddAsync(new Models.Team.Team()
{
Name = team.Name,
ClubId = team.ClubId
});
var result = AutoMapper.Mapper.Map <DTO.Team.Output.Team>(teamResult);
return(Ok(result));
}
public async Task <IActionResult> Create([Bind("Name")] Team team)
{
if (ModelState.IsValid)
{
await _teamRepository.AddAsync(team);
await _sharedRepository.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(team));
}
public async Task HandleAsync(AddTeam command)
{
if (command.Team == null)
{
throw new ServiceException(ErrorCodes.PustyRequest, "Post request add/team is empty");
}
if (command.Team.Workers.Count == 0)
{
throw new ServiceException(ErrorCodes.NiepoprawnyFormat, "Wybierz przynajmnniej jedego pracownika");
}
var team = _mapper.Map <Core.Models.Team>(command.Team);
team.TeamID = Guid.NewGuid();
await _teamRepository.AddAsync(team);
}
public async Task <TeamViewModel> CreateTeamAsync(TeamViewModel teamViewModel)
{
var mapped = _mapper.Map <Team>(teamViewModel);
if (mapped == null)
{
throw new Exception($"TeamModel entity could not be mapped");
}
var team = await _teamRepository.AddAsync(mapped);
var mappedViewModel = _mapper.Map <TeamViewModel>(team);
return(mappedViewModel);
}
public async Task <TeamResponse> SaveAsync(Team team)
{
try
{
await _teamRepository.AddAsync(team);
await _unitOfWork.CompleteAsync();
return(new TeamResponse(team));
}
catch (Exception ex)
{
// Do some logging stuff
return(new TeamResponse($"An error occurred when saving the team: {ex.Message}"));
}
}
public async Task <ActionResult <CreateTeamResponse> > CreateTeam([FromBody] CreateTeamRequest createTeamRequest, CancellationToken cancellationToken)
{
var team = new Team()
{
Name = createTeamRequest.Name,
FoundedIn = createTeamRequest.FoundedIn
};
await _teamsRepository.AddAsync(team, cancellationToken);
var response = new CreateTeamResponse
{
Team = _mapper.Map <TeamDto>(team)
};
return(Ok(response));
}
public async Task <IActionResult> Create([FromBody] TeamCreateDto team)
{
var country = await _countryRepository.GetByIdAsync(team.CountryId);
if (country == null)
{
return(BadRequest($"Invalid country Id { team.CountryId }"));
}
var newTeam = new Team(team.Name, country);
await _teamRepository.AddAsync(newTeam);
await _unitOfWork.Commit();
return(Ok());
}
public async Task <ActionResult <DtoTeam> > Add([FromBody] DtoTeam dtoTeam)
{
log.LogInformation("Adding new dtoTeam {dtoTeam}", dtoTeam);
if (!ModelState.IsValid)
{
return(BadRequest(getModelStateErrorMessage()));
}
if (dtoTeam.ID != 0)
{
return(BadRequest("Cannot add with a valid id"));
}
var team = mapper.Map <Team>(dtoTeam);
var newTeam = await teamRepository.AddAsync(team);
return(mapper.Map <DtoTeam>(newTeam));
}
public async Task <Organisation> RegisterAsync(OrganisationRegistration organisationContract)
{
if (await repository.ExistsByAsync(o => o.Id == organisationContract.Id))
{
throw new NameAlreadyUsedException(organisationContract.Name);
}
var organisationEntity = organisationContract.ToEntity();
organisationEntity = await repository.AddAsync(organisationEntity);
var user = GeneratePasswordAndAttachAdminRole(organisationContract.AdminUser, organisationContract.Id);
user.CreatedAt = DateTime.Now;
user = await userRepository.AddAsync(user);
var administrationTeam = new Domain.Entities.Team
{
Name = "org-admin",
TeamCode = "org-admin",
OrganisationId = organisationContract.Id,
CreatedAt = DateTime.Now
};
administrationTeam.Users.Add(new Domain.Entities.TeamUser(user));
administrationTeam = await teamRepository.AddAsync(administrationTeam);
user.TeamsPermissions.Add(new Domain.Entities.TeamPermission
{
TeamCode = administrationTeam.TeamCode,
IsOwner = true
});
user = await userRepository.UpdateAsync(user);
return(organisationEntity.ToContract());
}
public async Task <ApiResponse <TeamDto> > CreateTeamAsync(TeamDto dto)
{
try
{
var projectFound = await _projectRepository.GetByIdAsync(dto.ProjectId);
if (projectFound == null)
{
_logger.LogWarning("Failed to found project by id {0}", dto.ProjectId);
return(new ApiResponse <TeamDto>()
{
StatusCode = 400,
IsSuccess = false,
ResponseException = new ApiError(ErrorCode.ProjectNotFound, ErrorCode.ProjectNotFound.GetDescription())
});
}
var entityToAdd = _teamMapper.MapToEntity(dto);
entityToAdd = await _teamRepository.AddAsync(entityToAdd);
if (entityToAdd != null)
{
return(new ApiResponse <TeamDto>(dto));
}
_logger.LogWarning("Failed to create entity {0}", JsonConvert.SerializeObject(dto));
return(new ApiResponse <TeamDto>()
{
StatusCode = 400,
IsSuccess = false,
ResponseException = new ApiError(ErrorCode.TeamCreationFailed, ErrorCode.TeamCreationFailed.GetDescription())
});
}
catch (Exception ex)
{
_logger.LogWarning(ex, "An error occured while creating new team {0} ", JsonConvert.SerializeObject(dto));
return(ApiResponse <TeamDto> .InternalError());
}
}
public async Task AddTeamAsync(Team newTeam)
{
await _teamRepository.AddAsync(_mapper.Map <DataRepository.DataEntities.TeamProfile>(newTeam));
}
public async Task AddAsync(Team item)
{
item.TeamId = Guid.NewGuid().ToString();
await _teamRepository.AddAsync(item);
}
