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); }