feat(authentication,groups): configured authentication & added groups…

… creation

Application/Groups/CreateGroupCommand.cs

@@ -1,5 +1,5 @@
 using Application.Shared.Command;
 
-namespace Application;
+namespace Application.Groups;
 
 public sealed record CreateGroupCommand(Guid GroupId, string GroupName, Guid UserId) : ICommand;

Application/Groups/Handlers/CreateGroupCommandHandler.cs

@@ -2,7 +2,7 @@
 using Domain;
 using Domain.Groups;
 
-namespace Application;
+namespace Application.Groups;
 
 public class CreateGroupCommandHandler : ICommandHandler<CreateGroupCommand>
 {

Application/Groups/Handlers/JoinGroupCommandHandler.cs

@@ -0,0 +1,30 @@
+using Application.Shared.Command;
+using Domain;
+using Domain.Groups;
+using MediatR;
+
+namespace Application;
+
+public class JoinGroupCommandHandler : ICommandHandler<JoinGroupCommand>
+{
+    private readonly IGroupRepository _groupRepository;
+
+    private readonly ISender sender;
+
+    public JoinGroupCommandHandler(IGroupRepository groupRepository)
+    {
+        _groupRepository = groupRepository;
+    }
+
+    public async Task Handle(JoinGroupCommand request, CancellationToken cancellationToken = default)
+    {
+        var groupId = GroupId.Create(request.GroupId);
+        var memberId = UserId.Create(request.NewMember);
+
+        var criteria = new GroupByIdCriteria(groupId);
+
+        var group = await _groupRepository.MatchFirst(criteria);
+
+        group.Join(memberId);
+    }
+}

Application/Groups/JoinGroupCommand.cs

@@ -0,0 +1,18 @@
+using Application.Shared.Command;
+
+namespace Application;
+
+public sealed record JoinGroupCommand : ICommand
+{
+    public JoinGroupCommand(Guid newMember, Guid groupId)
+    {
+        NewMember = newMember;
+        GroupId = groupId;
+    }
+
+    public Guid NewMember { get; set; }
+
+    public Guid GroupId { get; set; }
+
+
+}

Application/Users/Commands/CreateUserCommand.cs

@@ -0,0 +1,11 @@
+
+using Application.Shared.Command;
+
+namespace Application;
+
+public sealed record CreateUserCommand : ICommand
+{
+    public Guid Id { get; set; }
+
+    public string Mail { get; set; }
+}

Application/Users/Commands/Handlers/CreateUserCommandHandler.cs

@@ -0,0 +1,24 @@
+using Application.Shared.Command;
+using Domain;
+
+namespace Application;
+
+public class CreateUserCommandHandler : ICommandHandler<CreateUserCommand>
+{
+    private readonly IUserRepository _userRepository;
+
+    public CreateUserCommandHandler(IUserRepository userRepository)
+    {
+        _userRepository = userRepository;
+    }
+
+    public async Task Handle(CreateUserCommand request, CancellationToken cancellationToken)
+    {
+        var id = UserId.Create(request.Id);
+        var mail = UserMail.Create(request.Mail);
+
+        var user = User.Create(id, mail);
+
+        await _userRepository.Add(user);
+    }
+}

Domain/Groups/Entities/Group.cs

@@ -12,14 +12,17 @@ public class Group : AggregateRoot<Group>
 
     public HashSet<UserId> Members { get; private set; } = new();
 
-    public List<GroupRecords> Records { get; private set; } = new();
+    public List<GroupRecord> Records { get; private set; } = new();
 
     private Group()
     {
     }
 
     protected Group(GroupId id, GroupName name, UserId admin)
     {
+        Id = id;
+        Name = name;
+        Admin = admin;
     }
 
     public static Group Create(GroupId id, GroupName name, UserId admin)

Domain/Groups/Repository/Criteria/GroupByIdCriteria.cs

@@ -0,0 +1,11 @@
+using System.Linq.Expressions;
+using Domain.Shared.Base;
+
+namespace Domain.Groups;
+
+public class GroupByIdCriteria : Criteria<Group>
+{
+    public GroupByIdCriteria(GroupId groupId) : base(group => group.Id == groupId)
+    {
+    }
+}

Domain/Groups/ValueObjects/GroupRecord.cs

@@ -0,0 +1,10 @@
+namespace Domain.Groups;
+
+public class GroupRecord
+{
+    public Decimal Amount { get; private set; }
+
+    public UserId Creator { get; private set; }
+
+    public List<RecordPercentage> Percentages { get; private set; }
+}

Domain/Groups/ValueObjects/RecordPercentage.cs

@@ -0,0 +1,26 @@
+namespace Domain;
+
+public class RecordPercentage
+{
+    public UserId Member { get; set; }
+
+    public Decimal Percentage { get; set; }
+
+    private RecordPercentage()
+    {
+    }
+
+    private RecordPercentage(UserId member, Decimal percentage)
+    {
+        Member = member;
+        Percentage = percentage;
+    }
+
+    public static RecordPercentage Create(UserId member, Decimal percentage)
+    {
+        if (percentage < 0 || percentage > 1)
+            throw new ArgumentOutOfRangeException(nameof(percentage));
+
+        return new RecordPercentage(member, percentage);
+    }
+}

Infrastructure/Authentication/Options/JwtBearerOptionsSetup.cs

@@ -5,7 +5,7 @@
 
 namespace Infrastructure;
 
-public class JwtBearerOptionsSetup : IConfigureOptions<JwtBearerOptions>
+public class JwtBearerOptionsSetup : IConfigureNamedOptions<JwtBearerOptions>
 {
     private readonly JwtOptions _options;
 
@@ -14,6 +14,11 @@ public JwtBearerOptionsSetup(IOptions<JwtOptions> options)
         _options = options.Value;
     }
 
+    public void Configure(string? name, JwtBearerOptions options)
+    {
+        Configure(options);
+    }
+
     public void Configure(JwtBearerOptions options)
     {
         options.TokenValidationParameters = new()

Persistance/DependencyInjection.cs

@@ -1,6 +1,5 @@
 using Domain.Shared.Base;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Persistance.Jobs;
@@ -12,6 +11,7 @@
 using Domain.Expenses;
 using Domain.Budgets;
 using Domain;
+using Domain.Groups;
 
 namespace Persistance;
 public static class DependencyInjection
@@ -59,6 +59,7 @@ public static IServiceCollection AddPersistance(this IServiceCollection services
         services.AddScoped<IExpenseRepository, ExpenseRepository>();
         services.AddScoped<IBudgetRepository, BudgetRepository>();
         services.AddScoped<IUserRepository, UserRepository>();
+        services.AddScoped<IGroupRepository, GroupRepository>();
 
         services.AddQuartzHostedService();
 

Persistance/Entities/Groups/Configuration/GroupConfiguration.cs

@@ -0,0 +1,71 @@
+using Domain;
+using Domain.Groups;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Persistance;
+
+public class GroupConfiguration : IEntityTypeConfiguration<Group>
+{
+    public void Configure(EntityTypeBuilder<Group> builder)
+    {
+        builder.HasKey(group => group.Id);
+        builder.HasIndex(group => group.Id);
+        builder.Property(group => group.Id)
+            .HasConversion(
+                src => src.Value,
+                raw => GroupId.Create(raw));
+
+        builder.Property(group => group.Admin)
+            .HasConversion(
+                src => src.Value,
+                raw => UserId.Create(raw));
+
+        builder.Property(group => group.Name)
+            .HasMaxLength(50)
+            .HasConversion(
+                src => src.Value,
+                raw => GroupName.Create(raw));
+
+        builder.OwnsMany(
+            group => group.Members, 
+            membersBuilder => {
+                // TODO: review how to change this name from Value to MemberId
+                membersBuilder.HasKey(memberId => memberId.Value);
+                membersBuilder.ToTable("GroupMembers");
+            });
+
+        builder.OwnsMany(group => group.Records,
+            recordBuilder => {
+                var identityProperty = "GroupRecordId";
+                recordBuilder.Property<Guid>(identityProperty)
+                    .ValueGeneratedOnAdd();
+
+                recordBuilder.HasKey(identityProperty);
+
+                
+                recordBuilder.Property(record => record.Creator)
+                    .HasConversion(
+                        src => src.Value,
+                        raw => UserId.Create(raw));
+                
+                recordBuilder.Property(record => record.Amount);
+
+                recordBuilder.OwnsMany(record => record.Percentages,
+                    percentagesBuilder => {
+                        var percentageIdentityProperty = "MemberPercentageId";
+                        percentagesBuilder.Property<Guid>(percentageIdentityProperty)
+                            .ValueGeneratedOnAdd();
+                        percentagesBuilder.HasKey(percentageIdentityProperty);
+
+
+                        percentagesBuilder.Property(percentage => percentage.Member)
+                            .HasConversion(
+                                src => src.Value,
+                                raw => UserId.Create(raw));
+                        
+                        percentagesBuilder.Property(percentage => percentage.Percentage);
+                    });
+            });
+    }
+}

Persistance/Entities/Groups/Repository/GroupRepository.cs

@@ -0,0 +1,17 @@
+using Domain.Groups;
+using Persistance.Shared;
+
+namespace Persistance;
+
+internal class GroupRepository : AbstractRepository<Group>, IGroupRepository
+{
+    public GroupRepository(ApplicationDbContext dbContext) : base(dbContext)
+    {
+    }
+
+    public Task Delete(Group group)
+    {
+        _context.Set<Group>().Remove(group);
+        return Task.CompletedTask;
+    }
+}