public async Task <TeamDTO> CreateTeam(int userId, CreateTeamDTO newTeam)
{
using (_unitOfWork)
{
Team team = _mapper.Map <CreateTeamDTO, Team>(newTeam);
User user = await _unitOfWork.UserRepository.FindByID(userId);
if (user.MyTeams == null)
{
user.MyTeams = new List <Team>();
}
user.MyTeams.Add(team);
if (team.Members == null)
{
team.Members = new List <User>();
}
team.Members.Add(user);
await _unitOfWork.TeamRepository.Create(team);
await _unitOfWork.Save();
TeamDTO returnTeam = _mapper.Map <Team, TeamDTO>(team);
return(returnTeam);
}
}
public bool Create(CreateTeamDTO teamDTO)
{
var team = _context.Teams.FirstOrDefault(t => t.Name.Equals(teamDTO.Name));
if (team != null)
{
return(false);
}
var whiteboard = new Whiteboard
{
Posts = new List <Post>()
};
team = new Team
{
Name = teamDTO.Name,
Members = new List <User>(),
Whiteboard = whiteboard
};
_context.Teams.Add(team);
if (_context.SaveChanges() == 0)
{
return(false);
}
return(true);
}
public async Task <TeamDTO> CreateTeamAsync(CreateTeamDTO createTeamDTO)
{
var teamId = Guid.NewGuid();
var(key, salt) = CreateKeyAndSalt(createTeamDTO.Passphrase);
var team = new Team()
{
TeamUserId = createTeamDTO.TeamId,
TeamName = createTeamDTO.Name,
TeamId = teamId,
Passphrase = key,
Salt = salt
};
dbContext.Team.Add(team);
foreach (var member in createTeamDTO.Members)
{
var teamPlayer = new TeamPlayer()
{
PlayerId = Guid.NewGuid(),
TeamId = teamId,
Name = member.Name
};
dbContext.TeamPlayer.Add(teamPlayer);
team.Members.Add(teamPlayer);
}
await dbContext.SaveChangesAsync();
return(team.ToDto());
}
public IActionResult CreateTeam(CreateTeamDTO teamDTO)
{
if (!_teamService.Create(teamDTO))
{
return(BadRequest("The team could not be created"));
}
return(Ok());
}
public Task <CommandResponse> Post([FromBody] CreateTeamDTO value)
{
if (value == null)
{
throw new System.ArgumentNullException(nameof(value));
}
return(commandProcessor.ProcessAsync <TeamCommandHandler, CreateTeamCommand, CommandResponse>(new CreateTeamCommand(value, HttpContext.RequestServices)));
}
public async Task <IActionResult> CreateTeamAsync([FromBody] TeamCreateRequest request)
{
CreateTeamDTO serviceRequest = new CreateTeamDTO
{
CreatorId = User.GetUserId(),
Name = request.TeamName
};
int teamId = await teamService.CreateTeamAsync(serviceRequest);
return(new JsonResult(new
{
TeamId = teamId
}));
}
public IActionResult CreateTeam([FromBody] CreateTeamDTO createteamDTO)
{
var userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
Guid newId = Guid.NewGuid();
if (createteamDTO.NAME == null || createteamDTO.CAMPAIGN_CATEGORY_ID_C == null)
{
return(StatusCode(400, new
{
code = 400,
message = "Invalid input params: Name or Campaign_id_c",
}));
}
bool isTeamExist = _teamRepository.IsTeamExist(newId.ToString(), createteamDTO.NAME);
if (isTeamExist)
{
return(StatusCode(400, new
{
code = 400,
message = "Team Existed",
}));
}
bool res = _teamRepository.CreateTeam(newId.ToString(), createteamDTO.NAME, createteamDTO.DESCRIPTION, createteamDTO.REGION_ID_C, createteamDTO.CAMPAIGN_CATEGORY_ID_C, userID);
if (res)
{
return(StatusCode(200, new
{
code = 200,
message = "Ok",
data = new
{
id = newId
}
}));
}
else
{
return(StatusCode(400, new
{
code = 400,
message = "Fail",
}));
}
}
public async Task <ActionResult> CreateTeam(int creatorId, [FromBody] CreateTeamDTO newTeam)
{
try
{
TeamDTO result = await _teamService.CreateTeam(creatorId, newTeam);
if (result != null)
{
return(Ok(result));
}
return(BadRequest());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <TeamDTO> > CreateTeam(CreateTeamDTO createTeamDto)
{
if (await TeamExists(createTeamDto.TeamName))
{
return(BadRequest("That team already exist"));
}
var team = new UserTeam();
team.TeamName = createTeamDto.TeamName.ToUpper();
_teamRepository.add(team);
return(new TeamDTO
{
TeamName = createTeamDto.TeamName
});
}
public IActionResult Update([FromBody] CreateTeamDTO createteamDTO)
{
var userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (createteamDTO.NAME == null || createteamDTO.CAMPAIGN_CATEGORY_ID_C == null)
{
return(StatusCode(400, new
{
code = 400,
message = "Invalid input params: Name or Campaign_id_c",
}));
}
//bool isTeamExist = _teamRepository.IsTeamExist(createteamDTO.ID, createteamDTO.NAME);
//if (!isTeamExist)
//{
// return StatusCode(400, new
// {
// code = 400,
// message = "Team not exist",
// });
//}
bool res = _teamRepository.CreateTeam(createteamDTO.ID, createteamDTO.NAME, createteamDTO.DESCRIPTION, createteamDTO.REGION_ID_C, createteamDTO.CAMPAIGN_CATEGORY_ID_C, userID);
if (res)
{
return(StatusCode(200, new
{
code = 200,
message = "Ok",
data = new
{
id = createteamDTO.ID
}
}));
}
else
{
return(StatusCode(400, new
{
code = 400,
message = "Fail",
}));
}
}
public ActionResult Create(CreateTeamDTO data)
{
if (ModelState.IsValid)
{
Team team = new Team();
team.TeamName = data.TeamName;
team.Description = data.Description;
_dbContext.Teams.Add(team);
_dbContext.SaveChanges();
ViewBag.TransactionStatus = 1;
return(View());
}
else
{
ViewBag.TransactionStatus = 2;
return(View(data));
}
}
public async Task <int> CreateTeamAsync(CreateTeamDTO request)
{
TeamMember userAsTeamMember = await members.GetAsync(request.CreatorId);
if (userAsTeamMember != null)
{
throw new BadRequestException("User is already in a team!");
}
var team = new Team
{
Name = request.Name
};
int teamId = await teams.CreateAsync(team);
await AddTeamMemberAsync(teamId, request.CreatorId);
return(teamId);
}
public async Task CreateTeamAndLogin()
{
var createTeamDto = new CreateTeamDTO()
{
Name = "test team",
TeamId = "test1",
Passphrase = "test1",
Members = new List <TeamPlayerDTO>()
{
new TeamPlayerDTO("erik"),
new TeamPlayerDTO("jan"),
new TeamPlayerDTO("nejc"),
new TeamPlayerDTO("luka")
}
};
var content = RequestBodyFromObject(createTeamDto);
var response = await fixture.Client.PostAsync("/api/team", content);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
output.WriteLine(responseString);
var result = JsonConvert.DeserializeObject <ResponseDTO <TeamDTO> >(responseString);
var loginDto = new LoginDTO()
{
TeamId = "test1",
Passphrase = "test1"
};
content = RequestBodyFromObject(loginDto);
response = await fixture.Client.PostAsync("/api/team/login", content);
response.EnsureSuccessStatusCode();
responseString = await response.Content.ReadAsStringAsync();
output.WriteLine(responseString);
}
public CreateTeamCommand(CreateTeamDTO createTeamDTO, System.IServiceProvider serviceProvider)
{
this.CreateTeamDTO = createTeamDTO;
this.ServiceProvider = serviceProvider;
}
public async Task <ActionResult <TeamDTO> > CreateTeam(CreateTeamDTO createTeamDTO)
{
var team = await teamService.CreateTeamAsync(createTeamDTO);
return(Ok(team));
}
