Merge pull request #63 from TunNetCom/FixAndUpgrade

Add Organization process

src/TimeLogService/TimeLogService.Application/Feature/MessageBroker/Consumer/ProfileUser/ProfileUserConsumer.cs

@@ -1,15 +1,55 @@
-using TimeLogService.Application.Feature.UserAction.Commands.AddUser;
+using System.Collections.Generic;
+using TimeLogService.Application.Feature.OrganizationAction.Commands.AddOrganization;
+using TimeLogService.Application.Feature.OrganizationAction.Commands.AddOrganizationList;
+using TimeLogService.Application.Feature.UserAction.Commands.AddUser;
 
 namespace TimeLogService.Application.Feature.MessageBroker.Consumer.ProfileUser;
 
-public class ProfileUserConsumer(ILogger<ProfileUserConsumer> logger, IMediator mediator) : IConsumer<UserProfile>, IConsumer<CustomProblemDetailsResponce>
+public class ProfileUserConsumer(ILogger<ProfileUserConsumer> logger, IMediator mediator, IRepository<User> repository, IRepository<Organization> repositoryOrganization) : IConsumer<UserProfile>, IConsumer<CustomProblemDetailsResponce>
 {
     private readonly ILogger<ProfileUserConsumer> _logger = logger;
     private readonly IMediator _mediator = mediator;
+    private readonly IRepository<User> _repository = repository;
+    private readonly IRepository<Organization> _repositoryOrganization = repositoryOrganization;
 
     public async Task Consume(ConsumeContext<UserProfile> context)
     {
-        await _mediator.Send(new AddUserCommand(context.Message));
+        User user = await _repository.GetSingleAsync(x => x.UserId == context.Message.Id);
+
+        if (user is null)
+        {
+            await _mediator.Send(new AddUserCommand(context.Message));
+
+            if (context.Message.UserAccount.Count > 0)
+            {
+                IReadOnlyList<Organization> organizationList = await _repositoryOrganization.GetManyAsync(x => x.UserId == context.Message!.Id);
+
+                var existingAccountIds = new HashSet<string>(organizationList.Select(x => x.AccountId));
+
+                List<Organization> organizations = new List<Organization>();
+
+                foreach (UserOrganization org in context.Message.UserAccount!.Value)
+                {
+                    if (!existingAccountIds.Contains(org.AccountId))
+                    {
+                        organizations.Add(new Organization
+                        {
+                            AccountId = org.AccountId,
+                            AccountUri = org.AccountUri.ToString(),
+                            Name = org.AccountName,
+                            UserId = context.Message.Id,
+                            IsAionTimeApproved = false,
+                        });
+                    }
+                }
+
+                if (organizations.Count > 0)
+                {
+                    await _mediator.Send(new AddOrganizationListCommand(organizations));
+                }
+            }
+        }
+
         _logger.LogInformation(JsonConvert.SerializeObject(context.Message));
     }
 

src/TimeLogService/TimeLogService.Application/Feature/OrganizationAction/Commands/AddOrganizationList/AddOrganizationListCommand.cs

@@ -0,0 +1,9 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TimeLogService.Application.Feature.OrganizationAction.Commands.AddOrganizationList;
+
+public record class AddOrganizationListCommand(List<Organization> Organizations) : IRequest;

src/TimeLogService/TimeLogService.Application/Feature/OrganizationAction/Commands/AddOrganizationList/AddOrganizationListCommandHandler.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TimeLogService.Application.Feature.OrganizationAction.Commands.AddOrganizationList
+{
+    public class AddOrganizationListCommandHandler(IRepository<Organization> repository) : IRequestHandler<AddOrganizationListCommand>
+    {
+        private readonly IRepository<Organization> _repository = repository;
+
+        public async Task Handle(AddOrganizationListCommand request, CancellationToken cancellationToken)
+        {
+            await _repository.AddRangeAsync(request.Organizations);
+        }
+    }
+}

src/TimeLogService/TimeLogService.Application/Feature/UserAction/Commands/AddUser/AddUserCommand.cs

@@ -3,4 +3,4 @@
 
 namespace TimeLogService.Application.Feature.UserAction.Commands.AddUser;
 
-public record class AddUserCommand(UserProfile UserProfile) : IRequest<OneOf<True, False>>;
+public record class AddUserCommand(UserProfile UserProfile) : IRequest;

src/TimeLogService/TimeLogService.Application/Feature/UserAction/Commands/AddUser/AddUserCommandHandler.cs

@@ -9,7 +9,7 @@ public class AddUserCommandHandler(IRepository<User> repository, IMapper mapper)
         private readonly IRepository<User> _repository = repository;
         private readonly IMapper _mapper = mapper;
 
-        public async Task<OneOf<True,False>> Handle(AddUserCommand request, CancellationToken cancellationToken)
+        public async Task Handle(AddUserCommand request, CancellationToken cancellationToken)
         {
 
             User user = new()

src/TimeLogService/TimeLogService.Domain/Interfaces/Repositories/IRepository.cs

@@ -1,4 +1,6 @@
-namespace TimeLogService.Domain.Interfaces.Repositories;
+using System.Linq.Expressions;
+
+namespace TimeLogService.Domain.Interfaces.Repositories;
 
 public interface IRepository<T>
     where T : BaseEntity
@@ -7,6 +9,10 @@ public interface IRepository<T>
 
     Task<T?> GetByIdAsync(int id);
 
+    Task<IReadOnlyList<T>> GetManyAsync(Expression<Func<T, bool>> predicate);
+
+    Task<T?> GetSingleAsync(Expression<Func<T, bool>> predicate);
+
     Task AddAsync(T entity);
 
     Task AddRangeAsync(IEnumerable<T> entities);

src/TimeLogService/TimeLogService.Domain/Models/dbo/AionTimeSubscription.cs

@@ -8,7 +8,7 @@ public partial class AionTimeSubscription : BaseEntity
 
     public int OrganizationId { get; set; }
 
-    public virtual ICollection<AionTimeSubscriptionHistory>?  AionTimeSubscriptionHistories { get; set; } //= new List<AionTimeSubscriptionHistory>();
+    public virtual ICollection<AionTimeSubscriptionHistory>? AionTimeSubscriptionHistories { get; set; } // = new List<AionTimeSubscriptionHistory>();
 
     public virtual Organization? Organization { get; set; }
 }

src/TimeLogService/TimeLogService.Domain/Models/dbo/Organization.cs

@@ -12,9 +12,9 @@ public partial class Organization : BaseEntity
 
     public bool IsAionTimeApproved { get; set; }
 
-    public virtual ICollection<AionTimeSubscription>?  AionTimeSubscriptions { get; set; } //= new List<AionTimeSubscription>();
+    public virtual ICollection<AionTimeSubscription>? AionTimeSubscriptions { get; set; }
 
-    public virtual ICollection<Project>?  Projects { get; set; } //= new List<Project>();
+    public virtual ICollection<Project>? Projects { get; set; }
 
     public virtual User? User { get; set; }
 }

src/TimeLogService/TimeLogService.Domain/Models/dbo/Project.cs

@@ -18,5 +18,5 @@ public partial class Project : BaseEntity
 
     public virtual Organization? Organization { get; set; }
 
-    public virtual ICollection<WorkItem>?  WorkItems { get; set; } //= new List<WorkItem>();
+    public virtual ICollection<WorkItem>? WorkItems { get; set; } // = new List<WorkItem>();
 }

src/TimeLogService/TimeLogService.Domain/Models/dbo/User.cs

@@ -14,5 +14,5 @@ public partial class User : BaseEntity
 
     public int Revision { get; set; }
 
-    public virtual ICollection<Organization>?  Organizations { get; set; } //= new List<Organization>();
+    public virtual ICollection<Organization>? Organizations { get; set; } // = new List<Organization>();
 }

src/TimeLogService/TimeLogService.Domain/Models/dbo/WorkItem.cs

@@ -8,7 +8,7 @@ public partial class WorkItem : BaseEntity
 
     public virtual Project? Project { get; set; }
 
-    public virtual ICollection<WorkItemHistory>?  WorkItemHistories { get; set; } //= new List<WorkItemHistory>();
+    public virtual ICollection<WorkItemHistory>? WorkItemHistories { get; set; } // = new List<WorkItemHistory>();
 
-    public virtual ICollection<WorkItemTimeLog>?  WorkItemTimeLogs { get; set; } //= new List<WorkItemTimeLog>();
+    public virtual ICollection<WorkItemTimeLog>? WorkItemTimeLogs { get; set; } // = new List<WorkItemTimeLog>();
 }

src/TimeLogService/TimeLogService.Infrastructure/Repositories/Repository.cs

@@ -1,4 +1,7 @@
-namespace TimeLogService.Infrastructure.Repositories;
+using System;
+using System.Linq.Expressions;
+
+namespace TimeLogService.Infrastructure.Repositories;
 
 public class Repository<T>(TimeLogServiceDataBaseContext context)
     : IRepository<T>
@@ -54,4 +57,14 @@ public async Task DeleteRangeAsync(IEnumerable<T> entities)
         _context.RemoveRange(entities);
         _ = await _context.SaveChangesAsync();
     }
+
+    public async Task<IReadOnlyList<T>> GetManyAsync(Expression<Func<T, bool>> predicate)
+    {
+        return await _context.Set<T>().AsNoTracking().Where(predicate).ToListAsync();
+    }
+
+    public async Task<T?> GetSingleAsync(Expression<Func<T, bool>> predicate)
+    {
+        return await _context.Set<T>().AsNoTracking().Where(predicate).FirstOrDefaultAsync();
+    }
 }