private async Task <ClubDto> MakeNewClub()
{
Console.Write("Enter the new club name > ");
var clubName = Console.ReadLine().Trim();
Console.Write("Enter the club initials > ");
var clubInitials = Console.ReadLine().Trim();
var club = new ClubDto
{
Initials = clubInitials,
Name = clubName
};
try
{
var guid = await _apiClient.SaveClub(club);
club.Id = guid;
}
catch (Exception ex)
{
Console.WriteLine($"Oh Noes! There was an exception: {ex}");
throw;
}
return(club);
}
private async Task <(string userId, ClubResource addedClub1, ClubResource addedClub2)> SetUpPostFeed(
ClubSystemDbContext dbContext)
{
var clubRepository = new ClubRepository(dbContext);
var clubDto1 = new ClubDto {
Name = "Name1", UniversityName = "University1"
};
var clubDto2 = new ClubDto {
Name = "Name2", UniversityName = "University2"
};
var addedClub1 = clubRepository.AddClub(clubDto1);
var addedClub2 = clubRepository.AddClub(clubDto2);
const string userId = "1234";
var claimsPrincipal = GenerateClaimsPrincipalWithId(userId);
var addUserToClubDto1 = new AddUserToClubDto {
ClubId = addedClub1.Id
};
var addUserToClubDto2 = new AddUserToClubDto {
ClubId = addedClub2.Id
};
await clubRepository.AddUserToClub(addUserToClubDto1, claimsPrincipal);
await clubRepository.AddUserToClub(addUserToClubDto2, claimsPrincipal);
return(userId, addedClub1, addedClub2);
}
public void Execute(ClubDto request)
{
var club = Context.Clubs.Find(request.Id);
if (club == null || club.IsDeleted)
{
throw new EntityNotFoundException("Club");
}
if (request.Name != null)
{
club.Name = request.Name;
}
if (request.LeagueId != 0)
{
if (!Context.Leagues.Any(l => l.Id == request.LeagueId))
{
throw new EntityNotFoundException("League");
}
club.LeagueId = request.LeagueId;
}
if (request.CityId != 0)
{
if (!Context.Cities.Any(l => l.Id == request.CityId))
{
throw new EntityNotFoundException("City");
}
club.CityId = request.CityId;
}
Context.SaveChanges();
}
public async Task <ActionResult <Guid> > Post([FromBody] ClubDto club)
{
if (club == null)
{
throw new ArgumentNullException(nameof(club));
}
// special handling here, so that user can create new club if they have
// global permissions.
bool canEdit = false;
if (club.Id == default)
{
canEdit = await _authService.CanUserEdit(User, club.Initials);
}
else
{
canEdit = await _authService.CanUserEdit(User, club.Id);
}
if (!canEdit)
{
return(Unauthorized());
}
var clubBizObj = _mapper.Map <Club>(club);
await _clubService.SaveNewClub(clubBizObj);
var savedClub = (await _clubService.GetClubs(false)).First(c => c.Initials == club.Initials);
return(Ok(savedClub.Id));
}
public async Task EditClub(ClubDto dto)
{
var entity = db.Clubs.Find(dto.Id);
mapper.Map(dto, entity);
await db.SaveChangesAsync();
}
public ClubResource AddClub(ClubDto clubDto)
{
#region Checks
if (clubDto == null)
{
throw new ClubCannotBeNullException();
}
var clubValidator = new ClubValidator();
var validationResult = clubValidator.Validate(clubDto);
if (!validationResult.IsValid)
{
throw new ClubIsNotValidException(validationResult.Errors.First().ErrorMessage);
}
#endregion
var newClub = _mapper.Map <Club>(clubDto);
_context.Clubs.Add(newClub);
_context.SaveChanges();
var clubResource = _mapper.Map <ClubResource>(newClub);
return(clubResource);
}
public void ShouldThrowClubIsNotValidException()
{
var clubRepository = GetInMemoryClubRepository();
ClubDto emptyClub = new ClubDto();
Assert.Throws <ClubCannotBeNullException>(() => clubRepository.AddClub(null));
Assert.Throws <ClubIsNotValidException>(() => clubRepository.AddClub(emptyClub));
}
public Club(ClubDto dto, IEnumerable <ClubPlayerInfo> player)
{
Players = new ConcurrentDictionary <ulong, ClubPlayerInfo>(player.ToDictionary(playerinfo =>
playerinfo.AccountId));
Id = dto.Id;
ClanName = dto.Name;
ClanIcon = dto.Icon;
Logger.Information("New Club: {name} {type} {playercount}", ClanName, ClanIcon, Count);
}
public Club(ClubDto dto, ClubPlayerInfo[] Player)
{
_players = Player.ToDictionary(playerinfo => playerinfo.AccountId);
Clan_ID = dto.Id;
Clan_Name = dto.Name;
Clan_Icon = dto.Icon;
Logger.Information("New Club: {name} {type} {playercount}", Clan_Name, Clan_Icon, Count);
}
public async Task GetClubAsync()
{
// Act
ClubDto result = await _playersAppService.GetClubAsync(Guid.Parse("85ea0ccf-0fad-4c6f-b660-23e6004a777d"));
// Assert
result.Id.ShouldBe(Guid.Parse("d772238a-9871-47d7-84d5-c45083799954"));
result.Name.ShouldBe("Snooker Club 1");
}
public async Task <IActionResult> Edit(int id, [FromBody] ClubDto clubDto)
{
if (clubDto == null)
{
return(BadRequest("You send an invalid club"));
}
var clubInDb = _clubService.Exist(id)
.Include(t => t.ClubTypes)
.Include(r => r.ClubRegions).FirstOrDefault();
if (clubInDb == null)
{
return(BadRequest("Club doesn't exist!"));
}
var errorMsg = _clubService.CheckSameName(clubDto.Name);
if (errorMsg != null)
{
return(BadRequest(errorMsg));
}
// Clear Relationships
if (!_clubService.ClearRelations(clubInDb))
{
return(BadRequest("Club can't be updated!"));
}
// Validate and Add Types
var typesErrMsg = _clubService.AddTypeR(clubInDb, clubDto);
if (!string.IsNullOrWhiteSpace(typesErrMsg))
{
return(BadRequest(typesErrMsg));
}
// Validate and Add Region and/or country
var regionCountryErrMsg = _clubService.AddRegionCountryR(clubInDb, clubDto);
if (!string.IsNullOrWhiteSpace(regionCountryErrMsg))
{
return(BadRequest(regionCountryErrMsg));
}
clubDto = _clubService.Edit(clubInDb, clubDto);
var saved = await _clubService.SaveEf();
if (!saved)
{
return(BadRequest());
}
return(Ok(_clubService.Exist(clubDto.Id).ProjectTo <ClubDto>(_mapper.ConfigurationProvider).FirstOrDefault()));
}
public async Task <IActionResult> Save([FromBody] ClubDto dto)
{
if (!await this._service.HasAccess(dto))
{
return(Forbid());
}
await this._service.SaveAsync(dto);
return(Ok());
}
public Club(ClubDto dto, IEnumerable <ClubPlayerInfo> player)
{
Players = new ConcurrentDictionary <ulong, ClubPlayerInfo>(player.ToDictionary(playerinfo =>
playerinfo.AccountId));
Id = dto.Id;
ClanName = dto.Name;
ClanIcon = dto.Icon;
CheckMaster();
}
public ActionResult <string> Get(int id)
{
var club = new ClubDto
{
ClubType = ClubType.Iron,
Description = "Trusty 7-iron",
Name = "7-iron"
};
return(new OkObjectResult(club));
}
public void ShouldGetOnlyOneClub()
{
var clubRepository = GetInMemoryClubRepository();
var club1 = new ClubDto {
Name = "Name1", UniversityName = "University1"
};
clubRepository.AddClub(club1);
var result = clubRepository.GetAllClubs();
Assert.Single(result);
}
public void ShouldAddClub()
{
var clubRepository = GetInMemoryClubRepository();
var club1 = new ClubDto {
Name = "Name1", UniversityName = "University14"
};
var addedClub = clubRepository.AddClub(club1);
Assert.NotNull(addedClub);
Assert.Equal(addedClub.Name, club1.Name);
Assert.Equal(addedClub.UniversityName, club1.UniversityName);
}
public void ShouldAddAdvancedClub()
{
var clubRepository = GetInMemoryClubRepository();
var club1 = new ClubDto {
Name = "Name1", UniversityName = "University14"
};
var addedClub = clubRepository.AddClub(club1);
Assert.NotNull(addedClub);
Assert.Equal(addedClub.Name, club1.Name);
Assert.Equal(addedClub.UniversityName, club1.UniversityName);
// TODO: addedClub.members and club1.members will be compared
}
public async Task WriteSwSeriesToSS(SwObjects.Series series)
{
_club = await GetClub();
_boatClass = await GetBoatClass();
_fleet = await GetFleet();
_season = await GetSeason();
_series = await MakeSeries(series);
_competitors = await GetCompetitors(series);
await SaveRaces(series);
}
public async Task <IActionResult> AddClub([FromBody] ClubDto clubDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = User.FindFirst(JwtRegisteredClaimNames.Sub)?.Value;
var user = await _userManager.FindByIdAsync(userId);
clubDto.CreatedBy = user?.Id;
var newClub = _clubRepository.AddClub(clubDto);
return(Ok(newClub));
}
public IActionResult Post([FromBody] ClubDto value)
{
try
{
_addClubCommand.Execute(value);
return(StatusCode(201));
}
catch (EntityNotFoundException e)
{
return(NotFound(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private ClubDto GetClubDto(AngleSharp.Dom.IElement clubPage)
{
var clubDto = new ClubDto();
clubDto.Name = clubPage.QuerySelector(".clubName").TextContent;
clubDto.BadgeUrl = clubPage.QuerySelector(".badge-image").GetAttribute("src");
var clubHref = clubPage.GetAttribute("href");
clubDto.PLLink = GlobalConstants.PremierLeagueLink
.Replace("/clubs", string.Empty) + clubHref;
clubDto.Stadium = this.GetStadiumDto(clubPage);
return clubDto;
}
public IActionResult Put(int id, [FromBody] ClubDto value)
{
value.Id = id;
try
{
_editClubCommand.Execute(value);
return(NoContent());
}
catch (EntityNotFoundException e)
{
return(NotFound(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public void Execute(ClubDto request)
{
if (!Context.Leagues.Any(l => l.Id == request.LeagueId))
{
throw new EntityNotFoundException("League");
}
if (!Context.Cities.Any(l => l.Id == request.CityId))
{
throw new EntityNotFoundException("city");
}
Context.Clubs.Add(new Club {
Name = request.Name,
CityId = request.CityId,
IsDeleted = false,
LeagueId = request.LeagueId
});
Context.SaveChanges();
}
public void ShouldGetAllClub()
{
var clubRepository = GetInMemoryClubRepository();
var club1 = new ClubDto {
Name = "Name1", UniversityName = "University1"
};
var club2 = new ClubDto {
Name = "Name2", UniversityName = "University2"
};
clubRepository.AddClub(club1);
clubRepository.AddClub(club2);
var result = clubRepository.GetAllClubs();
Assert.Equal(2, result.Count());
}
public ActionResult Create(ClubDto club)
{
try
{
var clubInsert = new ClubDto
{
Name = club.Name,
CityId = club.CityId,
LeagueId = club.LeagueId
};
_addClubCommand.Execute(clubInsert);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(RedirectToAction(nameof(Index)));
}
}
public ActionResult Edit(int id, ClubDto clubDto)
{
try
{
// TODO: Add update logic here
var clubEdit = new ClubDto
{
Id = id,
LeagueId = clubDto.LeagueId,
Name = clubDto.Name,
CityId = clubDto.CityId
};
_editClubCommand.Execute(clubEdit);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <bool> HasAccess(ClubDto clubDto)
{
// Neuer Club
if (clubDto.Id == 0)
{
return(true);
}
// Administrator
var user = this._userService.CurrentUser();
if (user.Group == Group.Administrator)
{
return(true);
}
// Manger vom Club
var club = await this.GetSingleClubAsync(clubDto.Id);
return(club.Manager.Id == user.Id);
}
public async Task SaveAsync(ClubDto clubDto)
{
Club club;
if (clubDto.Id > 0)
{
club = await this.GetSingleClubAsync(clubDto.Id);
}
else
{
club = new Club();
await _context.Clubs.AddAsync(club);
}
club.Name = clubDto.Name;
club.City = clubDto.City;
club.Postcode = clubDto.Postcode;
club.Manager = this._userService.CurrentUser();
await _context.SaveChangesAsync();
}
public void ShouldReturnClub()
{
IClubRepository clubRepository = GetInMemoryClubRepository();
var club1 = new ClubDto {
Name = "Name1", UniversityName = "University1"
};
var club2 = new ClubDto {
Name = "Name2", UniversityName = "University2"
};
var addedClub1 = clubRepository.AddClub(club1);
var addedClub2 = clubRepository.AddClub(club2);
var response = clubRepository.GetClub(addedClub1.Id);
Assert.NotEqual(response, addedClub2);
var responseJson = JsonConvert.SerializeObject(response);
var addedClub1Json = JsonConvert.SerializeObject(addedClub1);
Assert.Equal(responseJson, addedClub1Json);
}
private Club CreateClub(ClubDto clubDto)
{
var club = new Club
{
Name = clubDto.Name,
BadgeUrl = clubDto.BadgeUrl,
PLLink = clubDto.PLLink,
Stadium = new Stadium
{
Name = clubDto.Stadium.Name,
},
SocialLinks = new SocialLinks
{
WebsiteLink = clubDto.SocialLinks.WebsiteLink,
FacebookLink = clubDto.SocialLinks.FacebookLink,
TweeterLink = clubDto.SocialLinks.TweeterLink,
InstagramLink = clubDto.SocialLinks.InstagramLink,
},
};
return club;
}
