public JsonResult ApplyForTournament(GroupTeamViewModel groupTeam)
{
JsonResult result = null;
try
{
var userId = _currentUserService.GetCurrentUserId();
if (userId == ANONYM)
{
result = Json(ViewModelResources.NoRights);
}
else
{
var tournamentRequest = new TournamentRequest {
TeamId = groupTeam.TeamId,
UserId = userId,
GroupId = groupTeam.GroupId
};
_requestService.Create(tournamentRequest);
result = Json(ViewModelResources.SuccessRequest);
}
}
catch (ArgumentException ex)
{
result = Json(ex.Message);
}
return(result);
}
/// <summary>
/// Maps TournamentRequest model.
/// </summary>
/// <param name="to">Target of the mapping</param>
/// <param name="from">Source of the mapping</param>
public static void Map(TournamentRequestEntity to, TournamentRequest from)
{
to.Id = from.Id;
to.UserId = from.UserId;
to.TeamId = from.TeamId;
to.GroupId = from.GroupId;
}
public IHttpActionResult Post([FromBody] TournamentRequest requestBody)
{
var rng = new Random();
var details = requestBody ?? new TournamentRequest();
using (var dataContext = new DataContext())
{
var userName = User.Identity.Name;
var user = dataContext
.Users
.Where(u => u.UserName == userName)
.FirstOrDefault();
var tournament = dataContext
.Tournaments
.Add(new Tournament
{
Key = Guid.NewGuid(),
Name = details.name,
Seed = rng.Next(),
Players = new List <Player>(),
Organizers = new[] { user },
});
dataContext.SaveChanges();
return(CreatedAtRoute(
"tournament-get",
new { tournamentKey = tournament.Key },
TournamentResponseProvider.Create(tournament)
));
}
}
public TournamentRequestBuilder()
{
_tournamentRequest = new TournamentRequest
{
TeamId = 1,
GroupId = 1,
UserId = 1,
};
}
/// <summary>
/// Adds new tournament request.
/// </summary>
/// <param name="newEntity">Tournament request to add.</param>
public void Add(TournamentRequest newEntity)
{
var newRequestEntity = new TournamentRequestEntity();
DomainToDal.Map(newRequestEntity, newEntity);
_dalRequest.Add(newRequestEntity);
_unitOfWork.Commit();
newEntity.Id = newRequestEntity.Id;
}
/// <summary>
/// Updates specified tournament request.
/// </summary>
/// <param name="updatedEntity">Updated request.</param>
public void Update(TournamentRequest updatedEntity)
{
var requestToUpdate = _dalRequest.SingleOrDefault(t => t.Id == updatedEntity.Id);
if (requestToUpdate == null)
{
throw new ConcurrencyException();
}
DomainToDal.Map(requestToUpdate, updatedEntity);
}
public TournamentRequest CreateTournamentRequest(int idTournament, string email)
{
var tournamentRequest = new TournamentRequest
{
Id_champ = idTournament,
Email = email
};
_context.TournamentRequests.InsertOnSubmit(tournamentRequest);
_context.SubmitChanges();
return(tournamentRequest);
}
private void VerifyCreateTournamentRequest(
TournamentRequest request,
Times times,
string message)
{
_tournamentRequestRepositoryMock
.Verify(
tr => tr.Add(
It.Is <TournamentRequest>(p => TournamentRequestAreEquals(p, request))),
times,
message);
_unitOfWorkMock.Verify(uow => uow.Commit(), times);
}
/// <summary>
/// Create a new request
/// </summary>
/// <param name="tournamentRequest">Contains Team Id, Group Id, User Id</param>
public void Create(TournamentRequest tournamentRequest)
{
var existCurrentUserTournamentRequest = _getTournamentRequestByAllQuery.Execute(
new FindByTeamTournamentCriteria {
GroupId = tournamentRequest.GroupId, TeamId = tournamentRequest.TeamId
});
if (existCurrentUserTournamentRequest == null)
{
_tournamentRequestRepository.Add(tournamentRequest);
_tournamentRequestRepository.UnitOfWork.Commit();
NotifyAdmins(tournamentRequest);
}
}
/// <summary>
/// Maps domain entity to presentation
/// </summary>
/// <param name="request"><see cref="TournamentRequest"/> domain entity.</param>
/// <param name="team">Team to bind</param>
/// <param name="user"> User who connects.</param>
/// <param name="tournament">Tournament to bind</param>
/// <returns> View model object</returns>
public static TournamentRequestViewModel Map(
TournamentRequest request,
Team team,
User user,
Tournament tournament)
{
return(new TournamentRequestViewModel {
Id = request.Id,
PersonId = request.UserId,
TeamId = request.TeamId,
PersonName = user.PersonName,
TeamTitle = team.Name,
TournamentId = tournament.Id,
TournamentTitle = tournament.Name
});
}
// POST: api/Tournament
public void Post(TournamentRequest request)
{
var tournament = new Tournament();
tournament.Active = true;
tournament.Title = request.Title;
tournament.Matches = new List <Match>();
if (request.Competitors == 2)
{
CreateBrackets(1, tournament.Matches);
}
else if (request.Competitors <= 4)
{
CreateBrackets(2, tournament.Matches);
}
else if (request.Competitors <= 8)
{
CreateBrackets(3, tournament.Matches);
}
else if (request.Competitors <= 16)
{
CreateBrackets(4, tournament.Matches);
}
else if (request.Competitors <= 32)
{
CreateBrackets(5, tournament.Matches);
}
else if (request.Competitors <= 64)
{
CreateBrackets(6, tournament.Matches);
}
else
{
throw new Exception("Too many competitors");
}
using (var context = new TournamentContext())
{
context.Tournaments.Add(tournament);
context.SaveChanges();
}
}
private void NotifyAdmins(TournamentRequest request)
{
var subject = string.Format(
Properties.Resources.TournamentRequestEmailSubjectToAdmins,
request.Id);
var body = string.Format(
Properties.Resources.TournamentRequestEmailBodyToAdmins,
request.Id,
request.UserId,
request.TournamentId,
request.TeamId);
var adminList = _userService.GetAdminsList();
foreach (var admin in adminList)
{
var emailMessage = new EmailMessage(admin.Email, subject, body);
_mailService.Send(emailMessage);
}
}
public IHttpActionResult Put(Guid tournamentKey, [FromBody] TournamentRequest requestBody)
{
if (requestBody == null)
{
return(BadRequest("No request body provided."));
}
using (var dataContext = new DataContext())
{
var tournament = dataContext.GetTournament(tournamentKey);
if (tournament == null)
{
return(NotFound());
}
tournament.Name = requestBody.name;
dataContext.SaveChanges();
return(Ok(TournamentResponseProvider.Create(tournament)));
}
}
private void MockGetRequestByIdQuery(TournamentRequest request)
{
_getRequestByIdQueryMock.Setup(tr => tr.Execute(It.IsAny <FindByIdCriteria>())).Returns(request);
}
private void MockGetAllTournamentRequestQuery(TournamentRequest testData)
{
_getRequestByAllQueryMock.Setup(tr => tr.Execute(It.IsAny <FindByTeamTournamentCriteria>())).Returns(testData);
}
private bool TournamentRequestAreEquals(TournamentRequest x, TournamentRequest y)
{
return(new TournamentRequestComparer().Compare(x, y) == 0);
}
/// <summary>
/// Add tournament request to collection.
/// </summary>
/// <param name="newTournamentRequest">Request to add</param>
/// <returns>Builder object with collection of requests.</returns>
public TournamentRequestServiceTestFixture AddTeam(
TournamentRequest newTournamentRequest)
{
_request.Add(newTournamentRequest);
return(this);
}
