Merge pull request #31 from Alper-Soy/develop

Prod - 08/26/2024

API/Controllers/AccountController.cs

@@ -12,7 +12,7 @@ namespace API.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
-public class AccountController(UserManager<User> userManager, TokenService tokenService) : ControllerBase
+public class AccountController(UserManager<AppUser> userManager, TokenService tokenService) : ControllerBase
 {
     [AllowAnonymous]
     [HttpPost("login")]
@@ -47,7 +47,7 @@ public async Task<ActionResult<AuthUserDto>> Register(RegisterDto registerDto)
         }
 
 
-        var user = new User
+        var user = new AppUser
         {
             DisplayName = registerDto.DisplayName,
             Email = registerDto.Email,
@@ -71,14 +71,14 @@ public async Task<ActionResult<AuthUserDto>> GetCurrentUser()
         return CreateUserObject(user);
     }
 
-    private AuthUserDto CreateUserObject(User user)
+    private AuthUserDto CreateUserObject(AppUser appUser)
     {
         return new AuthUserDto
         {
-            DisplayName = user.DisplayName,
-            Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url,
-            Token = tokenService.CreateToken(user),
-            Username = user.UserName
+            DisplayName = appUser.DisplayName,
+            Image = appUser.Photos.FirstOrDefault(x => x.IsMain)?.Url,
+            Token = tokenService.CreateToken(appUser),
+            Username = appUser.UserName
         };
     }
 }

API/Controllers/FollowController.cs

@@ -0,0 +1,21 @@
+using Application.Features.Followers.Commands.FollowToggle;
+using Application.Features.Followers.Queries.Follow;
+using Microsoft.AspNetCore.Mvc;
+
+namespace API.Controllers;
+
+public class FollowController : BaseApiController
+{
+    [HttpPost("{username}")]
+    public async Task<IActionResult> Follow(string username)
+    {
+        return HandleResult(await Mediator.Send(new FollowToggleCommand
+            { TargetUsername = username }));
+    }
+
+    [HttpGet("{username}")]
+    public async Task<IActionResult> GetFollowings(string username, string predicate)
+    {
+        return HandleResult(await Mediator.Send(new GetFollowQuery { Username = username, Predicate = predicate }));
+    }
+}

API/Extensions/IdentityServiceExtensions.cs

@@ -13,7 +13,7 @@ public static class IdentityServiceExtensions
 {
     public static IServiceCollection AddIdentityServices(this IServiceCollection services, IConfiguration config)
     {
-        services.AddIdentityCore<User>(opt =>
+        services.AddIdentityCore<AppUser>(opt =>
             {
                 opt.Password.RequireNonAlphanumeric = false;
                 opt.User.RequireUniqueEmail = true;

API/Program.cs

@@ -39,7 +39,7 @@
 try
 {
     var context = services.GetRequiredService<DataContext>();
-    var userManager = services.GetRequiredService<UserManager<User>>();
+    var userManager = services.GetRequiredService<UserManager<AppUser>>();
     await context.Database.MigrateAsync();
     await Seed.SeedData(context, userManager);
 }

API/Services/Auth/TokenService.cs

@@ -8,13 +8,13 @@ namespace API.Services.Auth;
 
 public class TokenService(IConfiguration config)
 {
-    public string CreateToken(User user)
+    public string CreateToken(AppUser appUser)
     {
         var claims = new List<Claim>
         {
-            new(ClaimTypes.Name, user.UserName),
-            new(ClaimTypes.NameIdentifier, user.Id),
-            new(ClaimTypes.Email, user.Email)
+            new(ClaimTypes.Name, appUser.UserName),
+            new(ClaimTypes.NameIdentifier, appUser.Id),
+            new(ClaimTypes.Email, appUser.Email)
         };
 
         var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config["TokenKey"]));

Application/Core/MappingProfiles.cs

@@ -10,20 +10,29 @@ public class MappingProfiles : Profile
 {
     public MappingProfiles()
     {
+        string currentUsername = null;
         CreateMap<Activity, Activity>();
 
         CreateMap<Activity, ActivityDto>()
             .ForMember(d => d.HostUsername, o => o.MapFrom(s => s.Attendees
-                .FirstOrDefault(x => x.IsHost).User.UserName));
+                .FirstOrDefault(x => x.IsHost).AppUser.UserName));
 
         CreateMap<ActivityAttendee, AttendeeDto>()
-            .ForMember(d => d.DisplayName, o => o.MapFrom(s => s.User.DisplayName))
-            .ForMember(d => d.Username, o => o.MapFrom(s => s.User.UserName))
-            .ForMember(d => d.Bio, o => o.MapFrom(s => s.User.Bio))
-            .ForMember(d => d.Image, o => o.MapFrom(s => s.User.Photos.FirstOrDefault(x => x.IsMain).Url));
+            .ForMember(d => d.DisplayName, o => o.MapFrom(s => s.AppUser.DisplayName))
+            .ForMember(d => d.Username, o => o.MapFrom(s => s.AppUser.UserName))
+            .ForMember(d => d.Bio, o => o.MapFrom(s => s.AppUser.Bio))
+            .ForMember(d => d.Image, o => o.MapFrom(s => s.AppUser.Photos.FirstOrDefault(x => x.IsMain).Url))
+            .ForMember(d => d.FollowersCount, o => o.MapFrom(s => s.AppUser.Followers.Count))
+            .ForMember(d => d.FollowingCount, o => o.MapFrom(s => s.AppUser.Followings.Count))
+            .ForMember(d => d.Following,
+                o => o.MapFrom(s => s.AppUser.Followers.Any(x => x.Observer.UserName == currentUsername)));
 
-        CreateMap<User, Features.Profiles.Contracts.ProfileDto>()
-            .ForMember(d => d.Image, s => s.MapFrom(o => o.Photos.FirstOrDefault(x => x.IsMain).Url));
+        CreateMap<AppUser, Features.Profiles.Contracts.ProfileDto>()
+            .ForMember(d => d.Image, s => s.MapFrom(o => o.Photos.FirstOrDefault(x => x.IsMain).Url))
+            .ForMember(d => d.FollowersCount, o => o.MapFrom(s => s.Followers.Count))
+            .ForMember(d => d.FollowingCount, o => o.MapFrom(s => s.Followings.Count))
+            .ForMember(d => d.Following,
+                o => o.MapFrom(s => s.Followers.Any(x => x.Observer.UserName == currentUsername)));
 
         CreateMap<Comment, CommentDto>()
             .ForMember(d => d.DisplayName, o => o.MapFrom(s => s.Author.DisplayName))

Application/Features/Activities/Commands/CreateActivity/CreateActivityHandler.cs

@@ -17,7 +17,7 @@ public async Task<Result<Unit>> Handle(CreateActivityCommand request, Cancellati
 
         var attendee = new ActivityAttendee
         {
-            User = user,
+            AppUser = user,
             Activity = request.Activity,
             IsHost = true
         };

Application/Features/Activities/Queries/GetActivities/GetActivitiesHandler.cs

@@ -1,5 +1,6 @@
 using Application.Core;
 using Application.Features.Activities.Contracts;
+using Application.Interfaces;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using MediatR;
@@ -8,12 +9,13 @@
 
 namespace Application.Features.Activities.Queries.GetActivities;
 
-public class GetActivitiesHandler(DataContext context, IMapper mapper)
+public class GetActivitiesHandler(DataContext context, IMapper mapper, IUserAccessor userAccessor)
     : IRequestHandler<GetActivitiesQuery, Result<List<ActivityDto>>>
 {
     public async Task<Result<List<ActivityDto>>> Handle(GetActivitiesQuery request, CancellationToken cancellationToken)
     {
-        var activities = await context.Activities.ProjectTo<ActivityDto>(mapper.ConfigurationProvider)
+        var activities = await context.Activities.ProjectTo<ActivityDto>(mapper.ConfigurationProvider,
+                new { currentUsername = userAccessor.GetUsername() })
             .ToListAsync(cancellationToken);
 
         return Result<List<ActivityDto>>.Success(activities);

Application/Features/Activities/Queries/GetActivity/GetActivityHandler.cs

@@ -1,5 +1,6 @@
 using Application.Core;
 using Application.Features.Activities.Contracts;
+using Application.Interfaces;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using MediatR;
@@ -8,12 +9,13 @@
 
 namespace Application.Features.Activities.Queries.GetActivity;
 
-public class GetActivityHandler(DataContext context, IMapper mapper)
+public class GetActivityHandler(DataContext context, IMapper mapper, IUserAccessor userAccessor)
     : IRequestHandler<GetActivityQuery, Result<ActivityDto>>
 {
     public async Task<Result<ActivityDto>> Handle(GetActivityQuery request, CancellationToken cancellationToken)
     {
-        var activity = await context.Activities.ProjectTo<ActivityDto>(mapper.ConfigurationProvider)
+        var activity = await context.Activities.ProjectTo<ActivityDto>(mapper.ConfigurationProvider,
+                new { currentUsername = userAccessor.GetUsername() })
             .FirstOrDefaultAsync(x => x.Id == request.Id);
 
         return Result<ActivityDto>.Success(activity);

Application/Features/Attendance/Commands/UpdateAttendance/UpdateAttendanceHandler.cs

@@ -17,14 +17,14 @@ public async Task<Result<Unit>> Handle(UpdateAttendanceCommand request, Cancella
 
         if (user == null) return null;
 
-        var activity = await context.Activities.Include(a => a.Attendees).ThenInclude(u => u.User)
+        var activity = await context.Activities.Include(a => a.Attendees).ThenInclude(u => u.AppUser)
             .SingleOrDefaultAsync(x => x.Id == request.Id);
 
         if (activity == null) return null;
 
-        var hostUsername = activity.Attendees.FirstOrDefault(x => x.IsHost)?.User?.UserName;
+        var hostUsername = activity.Attendees.FirstOrDefault(x => x.IsHost)?.AppUser?.UserName;
 
-        var attendance = activity.Attendees.FirstOrDefault(x => x.User.UserName == user.UserName);
+        var attendance = activity.Attendees.FirstOrDefault(x => x.AppUser.UserName == user.UserName);
 
         if (attendance != null && hostUsername == user.UserName) activity.IsCancelled = !activity.IsCancelled;
 
@@ -34,7 +34,7 @@ public async Task<Result<Unit>> Handle(UpdateAttendanceCommand request, Cancella
         {
             attendance = new ActivityAttendee
             {
-                User = user,
+                AppUser = user,
                 Activity = activity,
                 IsHost = false
             };

Application/Features/Attendance/Contracts/AttendeeDto.cs

@@ -6,4 +6,7 @@ public class AttendeeDto
     public string DisplayName { get; set; }
     public string Bio { get; set; }
     public string Image { get; set; }
+    public bool Following { get; set; }
+    public int FollowersCount { get; set; }
+    public int FollowingCount { get; set; }
 }

Application/Features/Followers/Commands/FollowToggle/FollowToggleCommand.cs

@@ -0,0 +1,9 @@
+using Application.Core;
+using MediatR;
+
+namespace Application.Features.Followers.Commands.FollowToggle;
+
+public class FollowToggleCommand : IRequest<Result<Unit>>
+{
+    public string TargetUsername { get; set; }
+}

Application/Features/Followers/Commands/FollowToggle/FollowToggleHandler.cs

@@ -0,0 +1,44 @@
+using Application.Core;
+using Application.Interfaces;
+using Domain.Entities;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Persistence;
+
+namespace Application.Features.Followers.Commands.FollowToggle;
+
+public class FollowToggleHandler(DataContext context, IUserAccessor userAccessor)
+    : IRequestHandler<FollowToggleCommand, Result<Unit>>
+{
+    public async Task<Result<Unit>> Handle(FollowToggleCommand request, CancellationToken cancellationToken)
+    {
+        var observer = await context.Users.FirstOrDefaultAsync(x =>
+            x.UserName == userAccessor.GetUsername());
+
+        var target = await context.Users.FirstOrDefaultAsync(x =>
+            x.UserName == request.TargetUsername);
+
+        if (target == null) return null;
+
+        var following = await context.UserFollowings.FindAsync(observer.Id, target.Id);
+
+        if (following == null)
+        {
+            following = new UserFollowing
+            {
+                Observer = observer,
+                Target = target
+            };
+
+            context.UserFollowings.Add(following);
+        }
+        else
+        {
+            context.UserFollowings.Remove(following);
+        }
+
+        var success = await context.SaveChangesAsync() > 0;
+
+        return success ? Result<Unit>.Success(Unit.Value) : Result<Unit>.Failure("Failed to update following");
+    }
+}

Application/Features/Followers/Queries/Follow/GetFollowHandler.cs

@@ -0,0 +1,39 @@
+using Application.Core;
+using Application.Features.Profiles.Contracts;
+using Application.Interfaces;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Persistence;
+
+namespace Application.Features.Followers.Queries.Follow;
+
+public class GetFollowHandler(DataContext context, IMapper mapper, IUserAccessor userAccessor)
+    : IRequestHandler<GetFollowQuery, Result<List<ProfileDto>>>
+{
+    public async Task<Result<List<ProfileDto>>> Handle(GetFollowQuery request, CancellationToken cancellationToken)
+    {
+        var profiles = new List<ProfileDto>();
+
+        switch (request.Predicate)
+        {
+            case "followers":
+                profiles = await context.UserFollowings.Where(x => x.Target.UserName == request.Username)
+                    .Select(u => u.Observer)
+                    .ProjectTo<ProfileDto>(mapper.ConfigurationProvider,
+                        new { currentUsername = userAccessor.GetUsername() })
+                    .ToListAsync();
+                break;
+            case "following":
+                profiles = await context.UserFollowings.Where(x => x.Observer.UserName == request.Username)
+                    .Select(u => u.Target)
+                    .ProjectTo<ProfileDto>(mapper.ConfigurationProvider,
+                        new { currentUsername = userAccessor.GetUsername() })
+                    .ToListAsync();
+                break;
+        }
+
+        return Result<List<ProfileDto>>.Success(profiles);
+    }
+}

Application/Features/Followers/Queries/Follow/GetFollowQuery.cs

@@ -0,0 +1,11 @@
+using Application.Core;
+using Application.Features.Profiles.Contracts;
+using MediatR;
+
+namespace Application.Features.Followers.Queries.Follow;
+
+public class GetFollowQuery : IRequest<Result<List<ProfileDto>>>
+{
+    public string Predicate { get; set; }
+    public string Username { get; set; }
+}

Application/Features/Profiles/Contracts/ProfileDto.cs

@@ -8,5 +8,8 @@ public class ProfileDto
     public string DisplayName { get; set; }
     public string Bio { get; set; }
     public string Image { get; set; }
+    public bool Following { get; set; }
+    public int FollowersCount { get; set; }
+    public int FollowingCount { get; set; }
     public ICollection<Photo> Photos { get; set; }
 }

Application/Features/Profiles/Queries/GetProfile/GetProfileHandler.cs

@@ -1,5 +1,6 @@
 using Application.Core;
 using Application.Features.Profiles.Contracts;
+using Application.Interfaces;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using MediatR;
@@ -8,13 +9,13 @@
 
 namespace Application.Features.Profiles.Queries.GetProfile;
 
-public class GetProfileHandler(DataContext context, IMapper mapper)
+public class GetProfileHandler(DataContext context, IMapper mapper, IUserAccessor userAccessor)
     : IRequestHandler<GetProfileQuery, Result<ProfileDto>>
 {
     public async Task<Result<ProfileDto>> Handle(GetProfileQuery request, CancellationToken cancellationToken)
     {
         var user = await context.Users
-            .ProjectTo<ProfileDto>(mapper.ConfigurationProvider)
+            .ProjectTo<ProfileDto>(mapper.ConfigurationProvider, new { currentUsername = userAccessor.GetUsername() })
             .SingleOrDefaultAsync(x => x.Username == request.Username);
 
         return Result<ProfileDto>.Success(user);

Domain/Entities/ActivityAttendee.cs

@@ -3,7 +3,7 @@ namespace Domain.Entities;
 public class ActivityAttendee
 {
     public string UserId { get; set; }
-    public User User { get; set; }
+    public AppUser AppUser { get; set; }
     public Guid ActivityId { get; set; }
     public Activity Activity { get; set; }
     public bool IsHost { get; set; }

Domain/Entities/User.cs → Domain/Entities/AppUser.cs

@@ -2,10 +2,12 @@
 
 namespace Domain.Entities;
 
-public class User : IdentityUser
+public class AppUser : IdentityUser
 {
     public string DisplayName { get; set; }
     public string Bio { get; set; }
     public ICollection<ActivityAttendee> Activities { get; set; }
     public ICollection<Photo> Photos { get; set; }
+    public ICollection<UserFollowing> Followings { get; set; }
+    public ICollection<UserFollowing> Followers { get; set; }
 }

Domain/Entities/Comment.cs

@@ -4,7 +4,7 @@ public class Comment
 {
     public int Id { get; set; }
     public string Body { get; set; }
-    public User Author { get; set; }
+    public AppUser Author { get; set; }
     public Activity Activity { get; set; }
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
 }