private static UserDTO GetCurrentClubAdmin(ClubDTO club)
{
return(club?.ClubAdministration
.Where(a => (a.EndDate >= DateTime.Now || a.EndDate == null) && a.AdminType.AdminTypeName == "Курінний")
.Select(a => a.ClubMembers.User)
.FirstOrDefault());
}
//Ask DAL to Add club
public string AddClub(ClubDTO club)
{
//Get list of current existing clubs
Clubs = GetClubs();
//Check if there's any club with given name
foreach (ClubDTO item in Clubs)
{
if (item.Name == club.Name)
{
message.Append("There's already an existing club with that name.");
return(message.ToString());
}
}
//If club doesn't exist yet, set default value to photo if not added.
Club c = Mapper.Map <Club>(club);
if (c.Photo is null || c.Photo == "")
{
c.Photo = "No photo";
}
if (Repository.AddClub(c))
{
message.Append("Club has been created!");
}
else
{
message.Append("Something went wrong.");
}
return(message.ToString());
}
private async Task UploadPhotoAsync(ClubDTO Club)
{
var oldImageName = (await _repoWrapper.Club.GetFirstOrDefaultAsync(i => i.ID == Club.ID))?.Logo;
var logoBase64 = Club.Logo;
if (!string.IsNullOrWhiteSpace(logoBase64) && logoBase64.Length > 0)
{
var logoBase64Parts = logoBase64.Split(',');
var extension = logoBase64Parts[0].Split(new[] { '/', ';' }, 3)[1];
if (!string.IsNullOrEmpty(extension))
{
extension = (extension[0] == '.' ? "" : ".") + extension;
}
var fileName = Guid.NewGuid() + extension;
await _ClubBlobStorage.UploadBlobForBase64Async(logoBase64Parts[1], fileName);
Club.Logo = fileName;
}
if (!string.IsNullOrEmpty(oldImageName))
{
await _ClubBlobStorage.DeleteBlobAsync(oldImageName);
}
}
private async Task UploadPhotoAsync(ClubDTO Club, IFormFile file)
{
var ClubId = Club.ID;
var oldImageName = (await _repoWrapper.Club.GetFirstOrDefaultAsync(
predicate: i => i.ID == ClubId))
?.Logo;
if (file != null && file.Length > 0)
{
using (var img = Image.FromStream(file.OpenReadStream()))
{
var uploads = Path.Combine(_env.WebRootPath, "images\\Clubs");
if (!string.IsNullOrEmpty(oldImageName))
{
var oldPath = Path.Combine(uploads, oldImageName);
if (File.Exists(oldPath))
{
File.Delete(oldPath);
}
}
var fileName = Guid.NewGuid() + Path.GetExtension(file.FileName);
var filePath = Path.Combine(uploads, fileName);
img.Save(filePath);
Club.Logo = fileName;
}
}
else
{
Club.Logo = oldImageName ?? null;
}
}
public async Task <bool> VerifyClubNameIsNotChangedAsync(ClubDTO club)
{
var originClub = await _repoWrapper.Club.GetFirstOrDefaultAsync(x => x.ID == club.ID);
var isTheSameClubName = originClub.ClubName == club.ClubName;
return(isTheSameClubName);
}
private async Task UploadPhotoAsync(ClubDTO club, IFormFile file)
{
var ClubId = club.ID;
var oldImageName = (await _repoWrapper.Club.GetFirstOrDefaultAsync(
predicate: i => i.ID == ClubId))
?.Logo;
club.Logo = GetChangedPhoto("images\\Clubs", file, oldImageName, _env.WebRootPath, _uniqueId.GetUniqueId().ToString());
}
public Club CalculatePercentage(ClubDTO clubDTO)
{
var percentage = (Convert.ToDouble(clubDTO.PointsEarned) / Convert.ToDouble(clubDTO.GamesPlayed * 3)) * 100;
return(new Club
{
Name = clubDTO.Name,
Percentage = percentage
});
}
/// <inheritdoc />
public async Task EditAsync(ClubDTO model)
{
await UploadPhotoAsync(model);
var Club = CreateClubAsync(model);
_repoWrapper.Club.Attach(Club);
_repoWrapper.Club.Update(Club);
await _repoWrapper.SaveAsync();
}
public async Task <IActionResult> Post([FromBody] ClubDTO club)
{
List <Error> errors = new List <Error>();
Account currentUser = await GetCurrentUserAsync();
List <ClubAdmins> listClubAdmin = new List <ClubAdmins>()
{
new ClubAdmins()
{
Account = currentUser
}
};
List <ClubMember> membres = new List <ClubMember>();
foreach (UserInfo user in club.Members)
{
var userRaw = _context.UserInfo.Where(u => u.Id == user.Id && u.CreatedBy.Id == currentUser.Id);
if (userRaw.Count() > 0)
{
UserInfo userInfo = userRaw.First();
membres.Add(new ClubMember()
{
UserInfo = userInfo
});
}
else
{
errors.Add(new Error()
{
Code = "MembersUnAuthorizeOrUnknow",
Description = "Un des membres que vous essayer d'ajouter n'existe pas ou vous n'êtes pas authoriser a y accéder"
});
}
}
errors = ClubDaoValidator.Validate(club, errors);
if (errors.Count <= 0)
{
Club newClub = new Club
{
Admins = listClubAdmin,
Members = membres,
Adresse = club.Adresse,
ContactMail = club.ContactMail,
Name = club.Name,
Phone = club.Phone
};
_context.Clubs.Add(newClub);
_context.SaveChanges();
club.Id = newClub.Id;
return(Created("clubs", club));
}
return(BadRequest(errors));
}
/// <inheritdoc />
public async Task <ClubDTO> UpdateAsync(ClubDTO club)
{
var editedClub = _mapper.Map <ClubDTO, DataAccessClub.Club>(club);
editedClub.Logo = await UploadPhotoAsyncFromBase64(club.ID, club.Logo);
_repoWrapper.Club.Update(editedClub);
await _repoWrapper.SaveAsync();
return(_mapper.Map <DataAccessClub.Club, ClubDTO>(editedClub));
}
public static ClubDTO TryGetExistingClubFromDb(ClubDTO club)
{
var foundClub = ServiceLocator.ClubService.EagerDisconnectedService.FindBy(t => t.Name == club.Name).FirstOrDefault();
if (CheckEquality(club, foundClub, "RoleHandler", "RegistrationDate", "Active", "Id"))
{
return(foundClub);
}
throw new ArgumentException($"A club with the same Name: {club.Name}, but with conflicting values already exsist in the database");
}
public Club CalculatePercentage(ClubDTO clubDTO)
{
// throw new System.NotImplementedException();
var percentage = (Convert.ToDouble(clubDTO.PointsEarned) / Convert.ToDouble(clubDTO.GamesPlayed) * 3) * 100;
return(new Club
{
Name = clubDTO.Name,
Percentage = percentage
});
}
public IActionResult CalculatePercentage([FromQuery] ClubDTO clubDTO)
{
try
{
var data = _serviceClub.CalculatePercentage(clubDTO);
return(Ok(data));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public static IClub MappFrom(ClubDTO club)
{
ClubModel clubModel = new ClubModel();
SetCommonDboProperties(clubModel, club);
clubModel.Name = club.Name;
clubModel.RegistrationDate = club.RegistrationDate;
clubModel.Logo = club.Logo;
clubModel.HomePage = club.HomePage;
clubModel.Description = club.Description;
clubModel.Address = MappFrom(club.Address);
return(clubModel);
}
public string PostClub([FromBody] ClubDTO club)
{
/*if (!ModelState.IsValid)
* {
* return BadRequest(ModelState);
* }
*
* _context.Clubs.Add(club);
* await _context.SaveChangesAsync();
*
* return CreatedAtAction("GetClub", new { id = club.ClubId }, club);*/
return(_clubs.AddClub(club));
}
public void UpdateClub(ClubDTO club)
{
string sql = "UPDATE vereniging SET ID=@id, Naam=@name, adresID =@aID, email=@email, wachtwoord=@passw, schemaID=@sID; UPDATE [lid-dienst-combo] SET ID=@id";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("ID", club.ID.ToString()));
parameters.Add(new KeyValuePair <string, string>("name", club.Name.ToString()));
parameters.Add(new KeyValuePair <string, string>("aID", club.Address.ID.ToString()));
parameters.Add(new KeyValuePair <string, string>("email", club.Email.ToString()));
parameters.Add(new KeyValuePair <string, string>("passw", club.Password.ToString()));
parameters.Add(new KeyValuePair <string, string>("sID", club.Schedule.ID.ToString()));
ExecuteQuery(sql, parameters);
}
/// <inheritdoc />
public async Task <int> CreateAsync(ClubDTO model)
{
await UploadPhotoAsync(model);
var Club = CreateClubAsync(model);
_repoWrapper.Club.Attach(Club);
await _repoWrapper.Club.CreateAsync(Club);
await _repoWrapper.SaveAsync();
return(Club.ID);
}
public void CreateAsync_InvalidOperationException()
{
// Arrange
ClubService clubService = CreateClubService();
ClubDTO clubDto = new ClubDTO
{
ID = 0
};
_repoWrapper.Setup(r => r.Club.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <DataAccessClub.Club, bool> > >(), null))
.ReturnsAsync(new DataAccessClub.Club());
// Act // Assert
Assert.ThrowsAsync <InvalidOperationException>(async() => await clubService.CreateAsync(clubDto));
}
//Remove given club
public string RemoveClub(ClubDTO club)
{
Club c = Mapper.Map <Club>(club);
if (Repository.RemoveClub(c))
{
message.Append("Club has succesfully been removed!");
}
else
{
//TODO Message exception
message.Append("Something went wrong.");
}
return(message.ToString());
}
//Ask clubs from DAL & map them to DTO format
public List <ClubDTO> GetClubs()
{
List <ClubDTO> list = Repository.GetAllClubs().ProjectTo <ClubDTO>(_mapper.ConfigurationProvider).ToList();
if (!list.Any())
{
throw new System.Exception("No clubs found.");
}
foreach (var item in list)
{
ClubDTO club = _mapper.Map <ClubDTO>(item);
Clubs.Add(club);
}
return(Clubs);
}
public ClubDTO FindClubById(int id)
{
string query = "Select * from clubs where id=@id";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("id", id.ToString()));
DataSet results = ExecuteQuery(query, parameters);
ClubDTO c = new ClubDTO();
if (results != null && results.Tables[0].Rows.Count > 0)
{
c = DataSetParser.DataSetToClub(results, 0);
}
return(c);
}
public static List <Error> Validate(ClubDTO club, List <Error> errors)
{
errors = AddressValidator.IsAdresseCorrect(club.Adresse, errors);
try
{
new MailAddress(club.ContactMail);
}
catch (ArgumentNullException)
{
errors.Add(new Error()
{
Code = "NullMailAddress",
Description = "L'adresse mail ne peut pas être vide"
}
);
}
catch (FormatException)
{
errors.Add(new Error()
{
Code = "IncorrectMailAddress",
Description = "Le format de l'adresse mail n'est pas reconnu"
}
);
}
if (club.Name == null || club.Name.Length <= 0)
{
errors.Add(new Error()
{
Code = "NameRequired",
Description = "Le nom du club ne peux pas être vide"
}
);
}
if (club.Phone == null || club.Phone.Length <= 0)
{
errors.Add(new Error()
{
Code = "PhoneRequired",
Description = "Le numero de telephone du club ne peux pas être vide"
}
);
}
return(errors);
}
/// <inheritdoc />
public async Task <int> CreateAsync(ClubDTO model)
{
if (await CheckCreated(model.Name))
{
throw new InvalidOperationException();
}
await UploadPhotoAsync(model);
var Club = CreateClubAsync(model);
_repoWrapper.Club.Attach(Club);
await _repoWrapper.Club.CreateAsync(Club);
await _repoWrapper.SaveAsync();
return(Club.ID);
}
public List <ClubDTO> GetAllClubs()
{
string query = "Select * from vereniging ";
List <KeyValuePair <string, string> > parameters = new List <KeyValuePair <string, string> >();
DataSet results = ExecuteQuery(query, parameters);
List <ClubDTO> clubs = new List <ClubDTO>();
if (results != null)
{
for (int x = 0; x < results.Tables[0].Rows.Count; x++)
{
ClubDTO c = DataSetParser.DataSetToClub(results, x);
clubs.Add(c);
}
}
return(clubs);
}
/// <summary>
/// Update a club
/// </summary>
/// <param name="clubDto">Club to update</param>
/// <returns></returns>
/// <exception cref="EntityNotFoundException<Club>"></exception>
public async Task UpdateAsync(ClubDTO clubDto)
{
await this.Repository.TransactionalExecutionAsync(
action : async(club, transaction) =>
{
//Check if the club already exists
var toUpdateClub = await this.Repository.GetByIdAsync(club.Id);
if (toUpdateClub == null)
{
throw new EntityNotFoundException <Club>();
}
toUpdateClub.CopyFrom(club);
//Save the club
await this.Repository.SaveChangesAsync();
},
obj : this.Mapper.Map <Club>(clubDto));
}
public async Task <IActionResult> Details(int ClubId)
{
try
{
ClubDTO ClubDto = await _ClubService.GetByIdAsync(ClubId);
if (ClubDto == null)
{
return(RedirectToAction("HandleError", "Error", new { code = StatusCodes.Status404NotFound }));
}
return(View(_mapper.Map <ClubDTO, ClubViewModel>(ClubDto)));
}
catch (Exception e)
{
_logger.LogError($"Exception :{e.Message}");
return(RedirectToAction("HandleError", "Error", new { code = StatusCodes.Status505HttpVersionNotsupported }));
}
}
public async Task CreateAsync_ReturnClubDtoID()
{
// Arrange
ClubService clubService = CreateClubService();
ClubDTO clubDto = new ClubDTO
{
ID = 0
};
_clubBlobStorage.Setup(b => b.UploadBlobForBase64Async(It.IsAny <string>(), It.IsAny <string>()));
_repoWrapper.Setup(r => r.Club.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <DataAccessClub.Club, bool> > >(), null))
.ReturnsAsync((DataAccessClub.Club)null);
// Act
var result = await clubService.CreateAsync(clubDto);
// Assert
Assert.AreEqual(clubDto.ID, result);
_clubBlobStorage.Verify(b => b.UploadBlobForBase64Async(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public async Task EditAsync_WithModel_ReturnsClubEdited()
{
// Arrange
ClubService clubService = CreateClubService();
ClubDTO clubDto = new ClubDTO
{
ID = 0
};
_repoWrapper.Setup(r => r.Club.Attach(It.IsAny <DataAccessClub.Club>()));
_repoWrapper.Setup(r => r.Club.Update(It.IsAny <DataAccessClub.Club>()));
_repoWrapper.Setup(r => r.SaveAsync());
// Act
await clubService.EditAsync(clubDto);
// Assert
_repoWrapper.Verify(r => r.Club.Attach(It.IsAny <DataAccessClub.Club>()), Times.Once);
_repoWrapper.Verify(r => r.Club.Update(It.IsAny <DataAccessClub.Club>()), Times.Once);
_repoWrapper.Verify(r => r.SaveAsync(), Times.Once);
}
/// <summary>
/// Create a new club
/// </summary>
/// <param name="clubDto">Club to crate</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="EntityAlreadyExistsException{TEntity}"<Club>"></exception>
public async Task <ClubDTO> CreateAsync(ClubDTO clubDto)
{
if (clubDto == null)
{
throw new ArgumentNullException(nameof(clubDto));
}
return(await this.Repository.TransactionalExecutionAsync(
action : async(club, transaction) =>
{
//Check if the club does not already exist
var searchedClub = await this.Repository.GetByUniqueKeyAsync(club);
if (searchedClub != null)
{
throw new EntityAlreadyExistsException <Club>(club);
}
//Add the club
await this.Repository.AddAsync(club);
await this.Repository.SaveChangesAsync();
},
obj : this.Mapper.Map <Club>(clubDto),
onSuccessFunc : (createdClub => this.Mapper.Map <ClubDTO>(createdClub))));
}
private DataAccessClub.Club CreateClubAsync(ClubDTO model)
{
var Club = _mapper.Map <ClubDTO, DataAccessClub.Club>(model);
return(Club);
}
