public async Task <string> Register(RegisterViewModel model)
{
await _authValidationService.ValidateRegisterViewModel(model);
var newUser = new ElanUser
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PasswordHintQuestion = model.Question,
PasswordHintAnswer = model.Answer,
Gender = model.Gender
};
var result = await _userManager.CreateAsync(newUser, model.Password);
if (!result.Succeeded)
{
throw new RegistrationFailedException(
$"An error occured while registering user: {result.Errors.Select(e => e.Description).Join(", ")}");
}
await _userSettings.AddSettings(newUser);
await _signInManager.SignInAsync(newUser, false);
return(GetToken(newUser));
}
public async Task <Post> CreatePost(ElanUser createdBy, string content, PrivacySetting?postVisibility = null, ElanUser userTo = null)
{
var visibility =
postVisibility ??
createdBy
.Settings
.FirstOrDefault(x => x.Setting == UserSetting.ViewPosts)?
.PrivacySetting ??
PrivacySetting.Friends;
var post = new Post
{
Content = content,
CreatedOn = DateTime.UtcNow,
CreatedBy = createdBy,
TargetUser = userTo ?? createdBy,
VisibilitySetting = visibility
};
await _dataService.GetSet <Post>().AddAsync(post);
await _dataService.SaveDbAsync();
return(post);
}
public async Task <ChatListing> GetMessagesAsync(ElanUser user1, ElanUser user2, int skip = 0, int take = 10)
{
var messagesQuery = _dataService
.GetSet <ChatMessage>()
.Where(m => (m.UserFromId == user1.Id && m.UserToId == user2.Id) ||
(m.UserFromId == user2.Id && m.UserToId == user1.Id));
var totalCount = messagesQuery.Count();
var messages =
await messagesQuery
.OrderByDescending(m => m.SentOn)
.Skip(skip * take)
.Take(take)
.OrderBy(m => m.SentOn)
.ToListAsync();
var model = new ChatListing
{
TotalCount = totalCount,
Messages = messages
};
return(model);
}
public async Task <ElanUserImage> GetMainImage(ElanUser user)
{
var userImageSet = _dataService.GetSet <ElanUserImage>();
var mainImage = await userImageSet.FirstOrDefaultAsync(x => x.UserId == user.Id && x.IsMain);
return(mainImage);
}
public UserProfileViewModel(ElanUser user)
{
Id = user.Id.ToString();
FirstName = user.FirstName;
LastName = user.LastName;
Description = user.Description;
Age = user.Age;
Gender = user.Gender;
}
public async Task <List <FriendsInvitation> > GetPendingInvitationsForUser(ElanUser user)
{
var result = await _dataService.GetSet <FriendsInvitation>()
.Include(i => i.UserFrom)
.Where(i => i.UserToId == user.Id && !i.IsAccepted && !i.IsRejected && !i.IsCanceled)
.ToListAsync();
return(result);
}
public async Task <int> GetNumberOfUnreadNotificationsForUser(ElanUser user)
{
var notificationsCount = await _dataService.GetSet <Notification>()
.Include(n => n.TargetUser)
.Where(n => n.TargetUser.Id == user.Id && n.IsDeleted != true && n.IsRead != true)
.CountAsync();
return(notificationsCount);
}
private ElanUser GetFriendUser(FriendsRelation relation, ElanUser user)
{
if (relation.FirstUser.Id == user.Id)
{
return(relation.SecondUser);
}
return(relation.FirstUser);
}
public async Task CancelInvitation(ElanUser cancelingUser, ElanUser invitedUser)
{
var invitation = await _dataService
.GetSet <FriendsInvitation>()
.SingleAsync(i => !i.IsAccepted && !i.IsRejected && !i.IsCanceled && i.UserFromId == cancelingUser.Id && i.UserToId == invitedUser.Id);
invitation.IsCanceled = true;
await _dataService.SaveDbAsync();
}
private async Task PushNumberOfNotifications(ElanUser user)
{
var connectionID = NotificationHub.GetConnectionID(user.UserName);
var notificationsCount = await _notificationService.GetNumberOfUnreadNotificationsForUser(user);
if (connectionID != null)
{
await _notificationHub.Clients.Client(connectionID).SendAsync("NotificationsCount", JsonConvert.SerializeObject(notificationsCount));
}
}
public async Task <bool> HasUnreadChatNotificationWithUser(ElanUser targetUser, ElanUser sourceUser)
{
var hasNotifications = await _dataService.GetSet <Notification>()
.Include(n => n.TargetUser)
.AnyAsync(n => n.TargetUser.Id == targetUser.Id &&
n.IsDeleted == false && n.IsRead == false &&
n.SourceId == sourceUser.Id.ToString() &&
n.Type == NotificationType.NewChatMessage);
return(hasNotifications);
}
public async Task <List <Notification> > GetActiveNotificationsForUser(ElanUser user, int skip = 0, int take = 10)
{
var notifications = await _dataService.GetSet <Notification>()
.Include(n => n.TargetUser)
.Where(n => n.TargetUser.Id == user.Id && n.IsDeleted != true)
.Skip(skip * take)
.Take(take)
.ToListAsync();
return(notifications);
}
public async Task <IList <ElanUserImage> > GetUserImages(ElanUser user)
{
var userImageSet = _dataService.GetSet <ElanUserImage>();
var userImages =
await userImageSet
.Where(ui => ui.UserId == user.Id)
.OrderByDescending(ui => ui.UploadDate)
.ToListAsync();
return(userImages);
}
public async Task <List <ElanUser> > GetFriendsForUser(ElanUser user)
{
var result = await _dataService.GetSet <FriendsRelation>()
.Include(u => u.FirstUser)
.Include(u => u.SecondUser)
.Include(u => u.FirstUser.Images)
.Include(u => u.SecondUser.Images)
.Where(u => u.FirstUser.Id == user.Id || u.SecondUser.Id == user.Id)
.Select(r => GetFriendUser(r, user))
.ToListAsync();
return(result);
}
public async Task <bool> IsInvitedByUser(ElanUser invitedUser, ElanUser invitingUser)
{
var invitation = await _dataService
.GetSet <FriendsInvitation>()
.Where(i => !i.IsAccepted && !i.IsRejected && !i.IsCanceled && i.UserFromId == invitingUser.Id && i.UserToId == invitedUser.Id)
.FirstOrDefaultAsync();
if (invitation != null)
{
return(true);
}
return(false);
}
public List <UserSearchResultViewModel> FindUsers(ElanUser user, string query, int skip, int take)
{
if (!_queryValidationService.IsValidQuery(query))
{
throw new Exception($"Query is invalid: {query}");
}
var result = _dataService.GetSet <ElanUser>()
.Where(x => !string.IsNullOrWhiteSpace(x.FirstName) &&
x.FirstName.Contains(query, StringComparison.CurrentCultureIgnoreCase) ||
!string.IsNullOrWhiteSpace(x.LastName) && x.LastName.Contains(query,
StringComparison.CurrentCultureIgnoreCase))
.OrderByDescending(x => x.FirstName.Contains(query, StringComparison.CurrentCultureIgnoreCase) &&
x.LastName.Contains(query, StringComparison.CurrentCultureIgnoreCase))
.ThenByDescending(x => x.LastName.Contains(query, StringComparison.CurrentCultureIgnoreCase))
.ThenByDescending(x => x.FirstUserFriends.Any(y =>
y.SecondUser.FirstUserFriends.Any(z => z.SecondUserId == user.Id) ||
y.SecondUser.SecondUserFriends.Any(z => z.FirstUserId == user.Id))
||
x.SecondUserFriends.Any(y =>
y.FirstUser.FirstUserFriends.Any(z => z.SecondUserId == user.Id) ||
y.FirstUser.SecondUserFriends.Any(z => z.FirstUserId == user.Id)))
.Skip(skip * take)
.Take(take)
.Select(x => new UserSearchResultViewModel
{
MutualFriendsCount = x.FirstUserFriends.Count(y =>
y.SecondUser.FirstUserFriends.Any(z => z.SecondUserId == user.Id) ||
y.SecondUser.SecondUserFriends.Any(z => z.FirstUserId == user.Id))
+
x.SecondUserFriends.Count(y =>
y.FirstUser.FirstUserFriends.Any(z => z.SecondUserId == user.Id) ||
y.FirstUser.SecondUserFriends.Any(z => z.FirstUserId == user.Id)),
FirstName = x.FirstName, LastName = x.LastName,
ImageRawValue = x.Images.FirstOrDefault(y => y.IsMain) != null
? x.Images.FirstOrDefault(y => y.IsMain).RawValue
: string.Empty,
Id = x.Id.ToString()
})
.ToList();
foreach (var searchResult in result.Where(x => !string.IsNullOrEmpty(x.ImageRawValue)))
{
searchResult.ImageRawValue = ImageUtil.Resize(searchResult.ImageRawValue, 30, 30);
}
return(result);
}
public async Task <FriendsRelation> CreateRelation(ElanUser firstUser, ElanUser secondUser)
{
var relation = new FriendsRelation
{
FirstUserId = firstUser.Id,
SecondUserId = secondUser.Id,
CreatedDate = DateTime.UtcNow
};
await _dataService.GetSet <FriendsRelation>().AddAsync(relation);
await _dataService.SaveDbAsync();
return(relation);
}
public async Task <ChatMessage> SaveMessage(ElanUser userFrom, ElanUser userTo, string message)
{
var chatMessage = new ChatMessage
{
UserFrom = userFrom,
UserTo = userTo,
Content = message,
SentOn = DateTime.UtcNow
};
await _dataService.GetSet <ChatMessage>().AddAsync(chatMessage);
await _dataService.SaveDbAsync();
return(chatMessage);
}
public async Task <FriendsInvitation> CreateInvitation(ElanUser userFrom, ElanUser userTo)
{
var invitation = new FriendsInvitation
{
UserFromId = userFrom.Id,
UserToId = userTo.Id,
CreatedDate = DateTime.UtcNow,
IsAccepted = false
};
await _dataService.GetSet <FriendsInvitation>().AddAsync(invitation);
await _dataService.SaveDbAsync();
return(invitation);
}
public async Task ChangeSettings(ElanUser user, List <UserSettingViewModel> settings)
{
var settingsSet = _dataService.GetSet <ElanUserSetting>();
foreach (var setting in settings)
{
var userSetting = new ElanUserSetting
{
UserId = user.Id,
Setting = setting.Setting,
PrivacySetting = setting.PrivacySetting
};
settingsSet.Update(userSetting);
}
await _dataService.SaveDbAsync();
}
public async Task RemoveRelation(ElanUser currentUser, ElanUser user)
{
var friendsRelationsSet = _dataService.GetSet <FriendsRelation>();
var relation = await friendsRelationsSet.FirstOrDefaultAsync(x =>
(x.FirstUserId == currentUser.Id && x.SecondUserId == user.Id) ||
(x.SecondUserId == currentUser.Id && x.FirstUserId == user.Id));
if (relation == null)
{
throw new RelationNotFoundException();
}
friendsRelationsSet.Remove(relation);
await _dataService.SaveDbAsync();
}
public async Task <PostListingViewModel> GetLatestPostsAsync(ElanUser user, int skip = 0, int take = 10)
{
var postsSet = _dataService.GetSet <Post>();
var userFriends = await _dataService.GetSet <FriendsRelation>()
.Where(x => x.FirstUserId == user.Id || x.SecondUserId == user.Id)
.Select(x => x.FirstUserId == user.Id ? x.SecondUserId : x.FirstUserId)
.ToListAsync();
userFriends.Add(user.Id);
var userFriendsSet = new HashSet <Guid>(userFriends);
var userPostsQuery = postsSet
.Where(x => x.BasePostId == null && userFriendsSet.Contains(x.CreatedById))
.OrderByDescending(m => m.CreatedOn);
var totalCount = userPostsQuery.Count();
var userPosts = await userPostsQuery.Skip(skip *take)
.Take(take)
.Include(m => m.CreatedBy)
.Include(m => m.Reactions)
.ToListAsync();
var filteredUsers = userFriendsSet.Where(x => userPosts.Any(y => y.CreatedById == x));
var filteredUsersImages = await GetUserAvatarThumbnails(filteredUsers);
foreach (var post in userPosts)
{
post.CommentsCount = postsSet.Count(x => x.BasePostId == post.Id);
post.UserImage = filteredUsersImages[post.CreatedById];
}
var model = new PostListingViewModel
{
Posts = userPosts,
TotalCount = totalCount
};
return(model);
}
public async Task <Post> CreatePostComment(ElanUser createdBy, string content, int postId)
{
var basePost = await GetPost(postId);
var postComment = new Post
{
BasePostId = postId,
Content = content,
CreatedBy = createdBy,
TargetUser = basePost.TargetUser,
CreatedOn = DateTime.UtcNow,
VisibilitySetting = PrivacySetting.Everyone
};
await _dataService.GetSet <Post>().AddAsync(postComment);
await _dataService.SaveDbAsync();
return(postComment);
}
public async Task AddSettings(ElanUser newUser)
{
var searchSetting = new ElanUserSetting
{
UserId = newUser.Id,
Setting = UserSetting.ProfileVisibility,
PrivacySetting = PrivacySetting.Everyone
};
_dataService.GetSet <ElanUserSetting>().Add(searchSetting);
var contentSetting = new ElanUserSetting
{
UserId = newUser.Id,
Setting = UserSetting.ViewPosts,
PrivacySetting = PrivacySetting.Everyone
};
_dataService.GetSet <ElanUserSetting>().Add(contentSetting);
await _dataService.SaveDbAsync();
}
public async Task <PostListingViewModel> GetPostsForUserAsync(ElanUser user, ElanUser currentUser, int skip, int take)
{
var postsSet = _dataService.GetSet <Post>();
var userPostsQuery = postsSet
.Where(x => x.BasePostId == null && x.CreatedById == user.Id);
if (user.Friends.All(x => x.FirstUserId != currentUser.Id && x.SecondUserId != currentUser.Id))
{
userPostsQuery = userPostsQuery
.Where(x => x.VisibilitySetting == PrivacySetting.Everyone);
}
var totalCount = userPostsQuery.Count();
var posts = await userPostsQuery.OrderByDescending(m => m.CreatedOn)
.Skip(skip * take)
.Take(take)
.Include(m => m.CreatedBy)
.Include(m => m.Reactions)
.ToListAsync();
var users = posts.Select(x => x.CreatedById).Distinct();
var authorsImages = await GetUserAvatarThumbnails(users);
foreach (var post in posts)
{
post.CommentsCount = postsSet.Count(x => x.BasePostId == post.Id);
post.UserImage = authorsImages[post.CreatedById];
}
var model = new PostListingViewModel
{
Posts = posts,
TotalCount = totalCount
};
return(model);
}
private string GetToken(ElanUser user)
{
var utcNow = DateTime.UtcNow;
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Iat, utcNow.ToString(CultureInfo.InvariantCulture))
};
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetValue <string>("Tokens:Key")));
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
signingCredentials: signingCredentials,
claims: claims,
notBefore: utcNow,
expires: utcNow.AddSeconds(_configuration.GetValue <int>("Tokens:Lifetime"))
);
return(new JwtSecurityTokenHandler().WriteToken(jwt));
}
public async Task <List <UserSettingViewModel> > GetSettingsForUser(ElanUser user)
{
var userSettings =
await _dataService
.GetSet <ElanUserSetting>()
.Where(x => x.UserId == user.Id)
.ToListAsync();
var result = new List <UserSettingViewModel>();
foreach (UserSetting setting in Enum.GetValues(typeof(UserSetting)))
{
var userSetting = userSettings.FirstOrDefault(x => x.Setting == setting);
result.Add(new UserSettingViewModel
{
Setting = setting,
PrivacySetting = userSetting?.PrivacySetting ?? PrivacySetting.Friends
});
}
return(result);
}
public UserViewModel(ElanUser user)
{
Id = user.Id.ToString();
UserName = user.GetDisplayName();
AvatarBase64 = ImageUtil.Resize(user.GetAvatar()?.RawValue, 30, 30);
}
public async Task <Notification> CreateNotification(string message, NotificationType notificationType, ElanUser userTo, string notificationSourceId)
{
var notification = new Notification
{
IsRead = false,
IsDeleted = false,
Message = message,
SentOn = DateTime.UtcNow,
Type = notificationType,
TargetUser = userTo,
SourceId = notificationSourceId
};
await _dataService.GetSet <Notification>().AddAsync(notification);
await _dataService.SaveDbAsync();
return(notification);
}
