public async Task <BlogDTO> GetByIdAsync(int id)
{
var blogEntity = await _blogRepository.GetByIdAsync(id);
if (blogEntity is null)
{
return(null);
}
var blogDTO = ToDTO(blogEntity);
var ratings = await _blogRatingRepository.GetAllByBlogIdAsync(id);
if (ratings.Any())
{
blogDTO.AverageRating = ratings.Average(br => br.Rate);
}
var currentUser = await _currentUserProvider.GetCurrentUserAsync();
if (currentUser != null)
{
var blogRating = await _blogRatingRepository
.GetByBlogIdAndUserIdAsync(id, currentUser.Id);
blogDTO.RatingByUser = blogRating is null ? default : blogRating.Rate;
}
return(blogDTO);
}
public async Task <GameFullDTO> CreateNewGameWithFriend(GameFullDTO game)
{
if (uow == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(game.Fen))
{
game.Fen = ChessGame.DefaultFen;
}
else
{
#warning кинуть исключение с информацией если Fen неккоректен
// var game = new ChessGame(entity.Fen);
}
game.Status = DataAccess.Helpers.GameStatus.Waiting;
var sides = game.Sides.ToList();
var currentUserSide = sides.Where(s => s.Player == null).First();
var opponent = sides.Where(s => s.Player != null).First().Player;
var currentUser = await _currentUserProvider.GetCurrentUserAsync();
currentUserSide.Player = mapper.Map <UserDTO>(currentUser);
game.Sides = new List <SideDTO>()
{
currentUserSide
};
GameFullDTO targetGame;
var gameRepo = uow.GetRepository <Game>();
var createdGame = await gameRepo
.GetOneAsync(g =>
g.Status == DataAccess.Helpers.GameStatus.Waiting &&
((g.Sides.Count() == 1 && g.Sides.First().PlayerId == currentUser.Id)
||
(g.Sides.Where(s => s.PlayerId == currentUser.Id).Count() > 0 && g.Sides.Where(s => s.Player == null).Count() > 0)));
if (createdGame != null)
{
createdGame.Fen = game.Fen;
createdGame.Sides = new List <Side>()
{
mapper.Map <Side>(currentUserSide)
};
targetGame = mapper.Map <GameFullDTO>(await gameRepo.UpdateAsync(createdGame));
await uow.SaveAsync();
}
else
{
game.CreationDate = DateTime.Now;
targetGame = await base.AddAsync(game);
}
await _notificationService.InviteUserAsync(opponent.Uid, targetGame.Id);
return(targetGame);
}
private async Task FillBaseEntityFields()
{
var user = await _currentUserProvider.GetCurrentUserAsync();
string userFullName = user is null ? "Anonymous" : user.FullName;
var now = DateTime.Now;
var entityEntries = ChangeTracker
.Entries <BaseEntity>()
.ToList();
entityEntries.ForEach(e =>
{
var entity = e.Entity;
entity.LastUpdateDate = now;
entity.LastUpdateBy = userFullName;
switch (e.State)
{
case EntityState.Added:
entity.DateCreated = now;
entity.CreatedBy = userFullName;
break;
case EntityState.Modified:
#region DateCreated and CreatedBy value should not be changed
entity.DateCreated = e.GetDatabaseValues().GetValue <DateTime>(BaseEntityFields.DateCreated);
entity.CreatedBy = e.GetDatabaseValues().GetValue <string>(BaseEntityFields.CreatedBy);
#endregion
break;
}
});
}
public async Task <UserProfileDTO> UpdateUserAsync(string email, UserUpdateDTO userUpdateDTO)
{
Preconditions.NotNullOrWhiteSpace(email, nameof(email));
Preconditions.NotNull(userUpdateDTO, nameof(userUpdateDTO));
var applicationUser = await _userManager.FindByEmailAsync(email);
if (applicationUser is null)
{
throw new EntityNotFoundException(nameof(ApplicationUser));
}
var currentUser = await _currentUserProvider.GetCurrentUserAsync();
if (currentUser is null)
{
throw new UnauthorizedAccessException();
}
if (!applicationUser.Equals(currentUser))
{
throw new InvalidOperationException();
}
applicationUser.FirstName = userUpdateDTO.FirstName;
applicationUser.LastName = userUpdateDTO.LastName;
applicationUser.ProfilePicture = userUpdateDTO.ProfilePicture;
var identityResult = await _userManager.UpdateAsync(applicationUser);
if (!identityResult.Succeeded)
{
return(null);
}
var userProfileDTO = _mapper.Map <UserProfileDTO>(applicationUser);
userProfileDTO.Roles = await _roleManager.GetUserRolesAsync(applicationUser);
return(userProfileDTO);
}
public async Task InsertAsync(BlogRatingDTO blogRatingDTO)
{
Preconditions.NotNull(blogRatingDTO, nameof(blogRatingDTO));
var user = await _currentUserProvider.GetCurrentUserAsync();
var currentRating = await _blogRatingRepository.GetByBlogIdAndUserIdAsync(blogRatingDTO.BlogID, user.Id);
if (currentRating is null)
{
var blogRatingEntity = _mapper.Map <BlogRating>(blogRatingDTO);
blogRatingEntity.ApplicationUserID = user.Id;
blogRatingEntity.CreatedBy = user.FullName;
blogRatingEntity.LastUpdateBy = user.FullName;
await _blogRatingRepository.InsertAsync(blogRatingEntity);
}
else
{
currentRating.Rate = blogRatingDTO.Rate;
currentRating.LastUpdateBy = user.FullName;
await _blogRatingRepository.UpdateAsync(currentRating);
}
}
public async Task <UserDTO> GetCurrentUser()
{
if (uow == null)
{
return(null);
}
var currentUser = await _currentUserProvider.GetCurrentUserAsync();
if (currentUser == null)
{
return(null);
}
var currentDbUser = await uow.GetRepository <User>()
.GetOneAsync(u => string.Equals(u.Uid, currentUser.Uid));
var currentUserDTO = mapper.Map <UserDTO>(currentUser);
currentUserDTO.Uid = currentUser.Uid;
currentUserDTO.Id = currentDbUser.Id;
return(currentUserDTO);
}
public async Task <List <UserSettingModel> > GetUserSettings()
{
var user = await _userProvider.GetCurrentUserAsync();
return(await _userSettingsRepository.GetUserSettings(user.Id));
}
