Admin: Create custom repositories for Event, EventRegistration and User

src/EventHub.Admin.Application/EventHubApplicationAutoMapperProfile.cs

@@ -6,6 +6,7 @@ using EventHub.Admin.Organizations.Memberships;
 using EventHub.Admin.Users;
 using EventHub.Countries;
 using EventHub.Events;
+using EventHub.Events.Registrations;
 using EventHub.Organizations;
 using EventHub.Organizations.Memberships;
 using Volo.Abp.AutoMapper;
@@ -36,6 +37,10 @@ namespace EventHub.Admin
                     opt => opt.MapFrom(user => user.Id));
 
             CreateMap<IdentityUser, UserDto>();
+
+            CreateMap<EventWithDetails, EventInListDto>();
+
+            CreateMap<EventRegistrationWithDetails, EventAttendeeDto>();
         }
     }
 }

src/EventHub.Admin.Application/Events/EventAppService.cs

@@ -6,8 +6,6 @@ using System.Threading.Tasks;
 using EventHub.Admin.Permissions;
 using EventHub.Countries;
 using EventHub.Events;
-using EventHub.Events.Registrations;
-using EventHub.Organizations;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.BlobStoring;
@@ -18,25 +16,18 @@ namespace EventHub.Admin.Events
     [Authorize(EventHubPermissions.Events.Default)]
     public class EventAppService : EventHubAdminAppService, IEventAppService
     {
-        private readonly IRepository<Event, Guid> _eventRepository;
-        private readonly IRepository<EventRegistration, Guid> _eventRegistrationRepository;
-        private readonly IRepository<Organization, Guid> _organizationRepository;
+        private readonly IEventRepository _eventRepository;
         private readonly IBlobContainer<EventCoverImageContainer> _eventBlobContainer;
         private readonly EventManager _eventManager;
         private readonly IRepository<Country, Guid> _countryRepository;
 
-
         public EventAppService(
-            IRepository<Event, Guid> eventRepository,
-            IRepository<EventRegistration, Guid> eventRegistrationRepository,
-            IRepository<Organization, Guid> organizationRepository,
+            IEventRepository eventRepository,
             IBlobContainer<EventCoverImageContainer> eventBlobContainer,
-            EventManager eventManager, 
+            EventManager eventManager,
             IRepository<Country, Guid> countryRepository)
         {
             _eventRepository = eventRepository;
-            _eventRegistrationRepository = eventRegistrationRepository;
-            _organizationRepository = organizationRepository;
             _eventBlobContainer = eventBlobContainer;
             _eventManager = eventManager;
             _countryRepository = countryRepository;
@@ -54,34 +45,14 @@ namespace EventHub.Admin.Events
 
         public async Task<PagedResultDto<EventInListDto>> GetListAsync(EventListFilterDto input)
         {
-            var eventQueryable = await _eventRepository.GetQueryableAsync();
-            var eventRegistrationQueryable = await _eventRegistrationRepository.GetQueryableAsync();
-            var organizationQueryable = await _organizationRepository.GetQueryableAsync();
-
-            var query = (from @event in eventQueryable
-                        join organization in organizationQueryable on @event.OrganizationId equals organization.Id
-                        select new EventInListDto
-                        {
-                            Id = @event.Id,
-                            Title = @event.Title,
-                            StartTime = @event.StartTime,
-                            OrganizationDisplayName = organization.DisplayName,
-                            AttendeeCount = (from eventRegistration in eventRegistrationQueryable
-                                             where eventRegistration.EventId == @event.Id
-                                             select @eventRegistration).Count()
-                        })
-                .WhereIf(!string.IsNullOrWhiteSpace(input.Title), x => x.Title.ToLower().Contains(input.Title.ToLower()))
-                .WhereIf(!string.IsNullOrWhiteSpace(input.OrganizationDisplayName), x => x.OrganizationDisplayName.ToLower().Contains(input.OrganizationDisplayName.ToLower()))
-                .WhereIf(input.MinStartTime.HasValue, x => x.StartTime >= input.MinStartTime)
-                .WhereIf(input.MaxStartTime.HasValue, x => x.StartTime <= input.MaxStartTime)
-                .WhereIf(input.MinAttendeeCount.HasValue, x => x.AttendeeCount >= input.MinAttendeeCount)
-                .WhereIf(input.MaxAttendeeCount.HasValue, x => x.AttendeeCount <= input.MaxAttendeeCount);
-
-            var totalCount = await AsyncExecuter.CountAsync(query);
-            query = query.OrderBy(string.IsNullOrWhiteSpace(input.Sorting) ? EventConsts.DefaultSorting : input.Sorting);
-            query = query.PageBy(input);
-
-            var events = await AsyncExecuter.ToListAsync(query);
+            var totalCount = await _eventRepository.GetCountAsync(input.Title, input.OrganizationDisplayName, input.MinAttendeeCount,
+                input.MaxAttendeeCount, input.MinStartTime, input.MaxStartTime);
+
+            var items = await _eventRepository.GetListAsync(input.Sorting, input.SkipCount, input.MaxResultCount,
+                input.Title, input.OrganizationDisplayName, input.MinAttendeeCount, input.MaxAttendeeCount,
+                input.MinStartTime, input.MaxStartTime);
+
+            var events = ObjectMapper.Map<List<EventWithDetails>, List<EventInListDto>>(items);
 
             return new PagedResultDto<EventInListDto>(totalCount, events);
         }
@@ -115,8 +86,8 @@ namespace EventHub.Admin.Events
             var countriesQueryable = await _countryRepository.GetQueryableAsync();
 
             var query = from country in countriesQueryable
-                orderby country.Name
-                select country;
+                        orderby country.Name
+                        select country;
 
             var countries = await AsyncExecuter.ToListAsync(query);
 

src/EventHub.Admin.Application/Events/Registrations/EventRegistrationAppService.cs

@@ -5,27 +5,25 @@ using System.Linq.Dynamic.Core;
 using System.Threading.Tasks;
 using EventHub.Admin.Permissions;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.Domain.Repositories;
-using Volo.Abp.Identity;
 using EventHub.Events.Registrations;
 using Microsoft.AspNetCore.Authorization;
 using EventHub.Events;
-using Volo.Abp;
+using EventHub.Users;
 
 namespace EventHub.Admin.Events.Registrations
 {
     [Authorize(EventHubPermissions.Events.Registrations.Default)]
     public class EventRegistrationAppService : EventHubAdminAppService, IEventRegistrationAppService
     {
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
-        private readonly IRepository<EventRegistration, Guid> _eventRegistrationRepository;
-        private readonly IRepository<Event, Guid> _eventRepository;
+        private readonly IUserRepository _userRepository;
+        private readonly IEventRegistrationRepository _eventRegistrationRepository;
+        private readonly IEventRepository _eventRepository;
         private readonly EventRegistrationManager _eventRegistrationManager;
 
         public EventRegistrationAppService(
-            IRepository<IdentityUser, Guid> userRepository, 
-            IRepository<EventRegistration, Guid> eventRegistrationRepository,
-            IRepository<Event, Guid> eventRepository,
+            IUserRepository userRepository, 
+            IEventRegistrationRepository eventRegistrationRepository,
+            IEventRepository eventRepository,
             EventRegistrationManager eventRegistrationManager)
         {
             _userRepository = userRepository;
@@ -36,29 +34,11 @@ namespace EventHub.Admin.Events.Registrations
 
         public async Task<PagedResultDto<EventAttendeeDto>> GetAttendeesAsync(GetEventRegistrationListInput input)
         {
-            var eventRegistrationQueryable = await _eventRegistrationRepository.GetQueryableAsync();
-            var userQueryable = await _userRepository.GetQueryableAsync();
-
-            var query = from eventRegistration in eventRegistrationQueryable
-                join user in userQueryable on eventRegistration.UserId equals user.Id
-                where eventRegistration.EventId == input.EventId
-                orderby eventRegistration.CreationTime descending
-                select user;
-
-            var totalCount = await AsyncExecuter.CountAsync(query);
-
-            if (!string.IsNullOrWhiteSpace(input.Sorting))
-            {
-                query = query.OrderBy(input.Sorting);
-            }
-
-            query = query.PageBy(input);
-            var users = await AsyncExecuter.ToListAsync(query.Take(10));
+            var totalCount = await _eventRegistrationRepository.GetCountAsync(input.EventId);
+            var items = await _eventRegistrationRepository.GetListAsync(input.EventId, input.Sorting, input.SkipCount, input.MaxResultCount);
+            var users = ObjectMapper.Map<List<EventRegistrationWithDetails>, List<EventAttendeeDto>>(items);
 
-            return new PagedResultDto<EventAttendeeDto>(
-                totalCount,
-                ObjectMapper.Map<List<IdentityUser>, List<EventAttendeeDto>>(users)
-            );
+            return new PagedResultDto<EventAttendeeDto>(totalCount, users);
         }
 
         [Authorize(EventHubPermissions.Events.Registrations.RemoveAttendee)]

src/EventHub.Admin.Application/Organizations/Memberships/OrganizationMembershipAppService.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using EventHub.Admin.Permissions;
 using EventHub.Organizations.Memberships;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -17,11 +18,11 @@ namespace EventHub.Admin.Organizations.Memberships
     public class OrganizationMembershipAppService : ApplicationService, IOrganizationMembershipAppService
     {
         private readonly IOrganizationMembershipRepository  _organizationMembershipRepository;
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
+        private readonly IUserRepository _userRepository;
         
         public OrganizationMembershipAppService(
-            IOrganizationMembershipRepository organizationMembershipRepository, 
-            IRepository<IdentityUser, Guid> userRepository)
+            IOrganizationMembershipRepository organizationMembershipRepository,
+            IUserRepository userRepository)
         {
             _organizationMembershipRepository = organizationMembershipRepository;
             _userRepository = userRepository;

src/EventHub.Admin.Application/Organizations/OrganizationAppService.cs

@@ -5,6 +5,7 @@ using System.Linq.Dynamic.Core;
 using System.Threading.Tasks;
 using EventHub.Admin.Permissions;
 using EventHub.Organizations;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -18,12 +19,12 @@ namespace EventHub.Admin.Organizations
     public class OrganizationAppService : EventHubAdminAppService, IOrganizationAppService
     {
         private readonly IRepository<Organization, Guid> _organizationRepository;
-        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
+        private readonly IUserRepository _identityUserRepository;
         private readonly IBlobContainer<OrganizationProfilePictureContainer> _organizationBlobContainer;
 
         public OrganizationAppService(
             IRepository<Organization, Guid> organizationRepository,
-            IRepository<IdentityUser, Guid> identityUserRepository,
+            IUserRepository identityUserRepository,
             IBlobContainer<OrganizationProfilePictureContainer> organizationBlobContainer)
         {
             _organizationRepository = organizationRepository;

src/EventHub.Admin.Application/Users/UserAppService.cs

@@ -1,12 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Dynamic.Core;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using EventHub.Admin.Permissions;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Identity;
 
 namespace EventHub.Admin.Users
@@ -14,31 +11,20 @@ namespace EventHub.Admin.Users
     [Authorize(EventHubPermissions.Users.Default)]
     public class UserAppService : EventHubAdminAppService, IUserAppService
     {
-        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
+        private readonly IUserRepository _userRepository;
 
-        public UserAppService(IRepository<IdentityUser, Guid> identityUserRepository)
+        public UserAppService(IUserRepository userRepository)
         {
-            _identityUserRepository = identityUserRepository;
+            _userRepository = userRepository;
         }
 
         public async Task<PagedResultDto<UserDto>> GetListAsync(GetUserListInput input)
         {
-            var identityUserQueryable = await _identityUserRepository.GetQueryableAsync();
+            var totalCount = await _userRepository.GetCountAsync(input.Username);
+            var items = await _userRepository.GetListAsync(input.Sorting, input.SkipCount, input.MaxResultCount, input.Username);
+            var users = ObjectMapper.Map<List<IdentityUser>, List<UserDto>>(items);
 
-            var query = identityUserQueryable
-                .WhereIf(!string.IsNullOrWhiteSpace(input.Username), user => user.UserName.ToLower().Contains(input.Username.ToLower()));
-
-            var totalCount = await AsyncExecuter.CountAsync(query);
-
-            if (!string.IsNullOrWhiteSpace(input.Sorting))
-            {
-                query = query.OrderBy(input.Sorting);
-            }
-
-            query = query.PageBy(input);
-
-            var users = await AsyncExecuter.ToListAsync(query);
-            return new PagedResultDto<UserDto>(totalCount, ObjectMapper.Map<List<IdentityUser>, List<UserDto>>(users));
+            return new PagedResultDto<UserDto>(totalCount, users);
         }
     }
 }

src/EventHub.Application/Events/EventAppService.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using EventHub.Countries;
 using EventHub.Events.Registrations;
 using EventHub.Organizations;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Authorization;
@@ -19,20 +20,20 @@ namespace EventHub.Events
     {
         private readonly EventManager _eventManager;
         private readonly EventRegistrationManager _eventRegistrationManager;
-        private readonly IRepository<EventRegistration, Guid> _eventRegistrationRepository;
-        private readonly IRepository<Event, Guid> _eventRepository;
+        private readonly IEventRegistrationRepository _eventRegistrationRepository;
+        private readonly IEventRepository _eventRepository;
         private readonly IRepository<Organization, Guid> _organizationRepository;
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
+        private readonly IUserRepository _userRepository;
         private readonly IRepository<Country, Guid> _countriesRepository;
         private readonly IBlobContainer<EventCoverImageContainer> _eventBlobContainer;
 
         public EventAppService(
             EventManager eventManager,
             EventRegistrationManager eventRegistrationManager,
-            IRepository<EventRegistration, Guid> eventRegistrationRepository,
-            IRepository<Event, Guid> eventRepository,
+            IEventRegistrationRepository eventRegistrationRepository,
+            IEventRepository eventRepository,
             IRepository<Organization, Guid> organizationRepository,
-            IRepository<IdentityUser, Guid> userRepository,
+            IUserRepository userRepository,
             IRepository<Country, Guid> countriesRepository,
             IBlobContainer<EventCoverImageContainer> eventBlobContainer)
         {

src/EventHub.Application/Events/Registrations/EventRegistrationAppService.cs

@@ -2,9 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Users;
 using Volo.Abp.Identity;
 
@@ -13,16 +13,16 @@ namespace EventHub.Events.Registrations
     public class EventRegistrationAppService : EventHubAppService, IEventRegistrationAppService
     {
         private readonly EventRegistrationManager _eventRegistrationManager;
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
-        private readonly IRepository<Event, Guid> _eventRepository;
-        private readonly IRepository<EventRegistration, Guid> _eventRegistrationRepository;
+        private readonly IUserRepository _userRepository;
+        private readonly IEventRepository _eventRepository;
+        private readonly IEventRegistrationRepository _eventRegistrationRepository;
         private readonly EventRegistrationNotifier _eventRegistrationNotifier;
 
         public EventRegistrationAppService(
             EventRegistrationManager eventRegistrationManager,
-            IRepository<IdentityUser, Guid> userRepository,
-            IRepository<Event, Guid> eventRepository,
-            IRepository<EventRegistration, Guid> eventRegistrationRepository, 
+            IUserRepository userRepository,
+            IEventRepository eventRepository,
+            IEventRegistrationRepository eventRegistrationRepository, 
             EventRegistrationNotifier eventRegistrationNotifier)
         {
             _eventRegistrationManager = eventRegistrationManager;

src/EventHub.Application/Organizations/Memberships/OrganizationMembershipAppService.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using EventHub.Users;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Domain.Repositories;
@@ -13,15 +14,15 @@ namespace EventHub.Organizations.Memberships
     public class OrganizationMembershipAppService : EventHubAppService, IOrganizationMembershipAppService 
     {
         private readonly OrganizationMembershipManager _organizationMembershipManager;
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
+        private readonly IUserRepository _userRepository;
         private readonly IRepository<Organization, Guid> _organizationRepository;
-        private readonly IRepository<OrganizationMembership, Guid>  _organizationMembershipsRepository;
+        private readonly IOrganizationMembershipRepository  _organizationMembershipsRepository;
 
         public OrganizationMembershipAppService(
-            OrganizationMembershipManager organizationMembershipManager, 
-            IRepository<IdentityUser, Guid> userRepository, 
-            IRepository<Organization, Guid> organizationRepository, 
-            IRepository<OrganizationMembership, Guid> organizationMembershipsRepository)
+            OrganizationMembershipManager organizationMembershipManager,
+            IUserRepository userRepository, 
+            IRepository<Organization, Guid> organizationRepository,
+            IOrganizationMembershipRepository organizationMembershipsRepository)
         {
             _organizationMembershipManager = organizationMembershipManager;
             _userRepository = userRepository;

src/EventHub.Application/Organizations/OrganizationAppService.cs

@@ -17,17 +17,17 @@ namespace EventHub.Organizations
     public class OrganizationAppService : EventHubAppService, IOrganizationAppService
     {
         private readonly IRepository<Organization, Guid> _organizationRepository;
-        private readonly IRepository<OrganizationMembership, Guid>  _organizationMembershipsRepository;
+        private readonly IOrganizationMembershipRepository  _organizationMembershipsRepository;
         private readonly OrganizationManager _organizationManager;
         private readonly IBlobContainer<OrganizationProfilePictureContainer> _organizationBlobContainer;
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
+        private readonly IUserRepository _userRepository;
 
         public OrganizationAppService(
             IRepository<Organization, Guid> organizationRepository,
-            IRepository<OrganizationMembership, Guid> organizationMembershipsRepository,
+            IOrganizationMembershipRepository organizationMembershipsRepository,
             OrganizationManager organizationManager,
-            IBlobContainer<OrganizationProfilePictureContainer> organizationBlobContainer, 
-            IRepository<IdentityUser, Guid> userRepository)
+            IBlobContainer<OrganizationProfilePictureContainer> organizationBlobContainer,
+            IUserRepository userRepository)
         {
             _organizationRepository = organizationRepository;
             _organizationMembershipsRepository = organizationMembershipsRepository;

src/EventHub.Application/Users/UserAppService.cs

@@ -8,9 +8,9 @@ namespace EventHub.Users
 {
     public class UserAppService : EventHubAppService, IUserAppService
     {
-        private readonly IRepository<IdentityUser, Guid> _userRepository;
+        private readonly IUserRepository _userRepository;
         
-        public UserAppService(IRepository<IdentityUser, Guid> userRepository)
+        public UserAppService(IUserRepository userRepository)
         {
             _userRepository = userRepository;
         }

src/EventHub.Domain/Events/EventWithDetails.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace EventHub.Events
+{
+    public class EventWithDetails
+    {
+        public Guid Id { get; set; }
+
+        public string Title { get; set; }
+
+        public string OrganizationDisplayName { get; set; }
+
+        public int AttendeeCount { get; set; }
+
+        public DateTime StartTime { get; set; }
+    }
+}

src/EventHub.Domain/Events/IEventRepository.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Repositories;
+
+namespace EventHub.Events
+{
+    public interface IEventRepository : IRepository<Event, Guid>
+    {
+        Task<int> GetCountAsync(
+            string title = null,
+            string organizationDisplayName = null,
+            int? minAttendeeCount = null,
+            int? maxAttendeeCount = null,
+            DateTime? minStartTime = null,
+            DateTime? maxStartTime = null,
+            CancellationToken cancellationToken = default
+        );
+
+        Task<List<EventWithDetails>> GetListAsync(
+            string sorting = null,
+            int skipCount = 0,
+            int maxResultCount = int.MaxValue,
+            string title = null,
+            string organizationDisplayName = null,
+            int? minAttendeeCount = null,
+            int? maxAttendeeCount = null,
+            DateTime? minStartTime = null,
+            DateTime? maxStartTime = null,
+            CancellationToken cancellationToken = default
+        );
+    }
+}

src/EventHub.Domain/Events/Registrations/EventRegistrationWithDetails.cs

@@ -0,0 +1,20 @@
+using System;
+using Volo.Abp.Auditing;
+
+namespace EventHub.Events.Registrations
+{
+    public class EventRegistrationWithDetails : IHasCreationTime
+    {
+        public Guid UserId { get; set; }
+
+        public string UserName { get; set; }
+
+        public string Email { get; set; }
+
+        public string Name { get; set; }
+
+        public string Surname { get; set; }
+
+        public DateTime CreationTime { get; set; }
+    }
+}

src/EventHub.Domain/Events/Registrations/IEventRegistrationRepository.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Repositories;
+
+namespace EventHub.Events.Registrations
+{
+    public interface IEventRegistrationRepository : IRepository<EventRegistration, Guid>
+    {
+        Task<int> GetCountAsync(Guid eventId, CancellationToken cancellationToken = default);
+
+        Task<List<EventRegistrationWithDetails>> GetListAsync(
+            Guid eventId, 
+            string sorting = null, 
+            int skipCount = 0, 
+            int maxResultCount = int.MaxValue, 
+            CancellationToken cancellationToken = default
+        );
+    }
+}

src/EventHub.Domain/Users/IUserRepository.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Identity;
+
+namespace EventHub.Users
+{
+    public interface IUserRepository : IRepository<IdentityUser, Guid>
+    {
+        Task<List<IdentityUser>> GetListAsync(
+            string sorting = null,
+            int skipCount = 0,
+            int maxResultCount = int.MaxValue,
+            string username = null,
+            CancellationToken cancellationToken = default
+        );
+
+        Task<int> GetCountAsync(
+            string username = null, 
+            CancellationToken cancellationToken = default
+        );
+    }
+}

src/EventHub.EntityFrameworkCore/EntityFrameworkCore/Events/EventRepository.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using System.Threading;
+using System.Threading.Tasks;
+using EventHub.Events;
+using EventHub.Events.Registrations;
+using EventHub.Organizations;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+namespace EventHub.EntityFrameworkCore.Events
+{
+    public class EventRepository : EfCoreRepository<EventHubDbContext, Event, Guid>, IEventRepository
+    {
+        public EventRepository(IDbContextProvider<EventHubDbContext> dbContextProvider) : base(dbContextProvider)
+        {
+        }
+
+        public async Task<int> GetCountAsync(
+            string title = null, 
+            string organizationDisplayName = null, 
+            int? minAttendeeCount = null, 
+            int? maxAttendeeCount = null, 
+            DateTime? minStartTime = null, 
+            DateTime? maxStartTime = null, 
+            CancellationToken cancellationToken = default
+        )
+        {
+            var dbContext = await GetDbContextAsync();
+
+            var eventQueryable = await GetQueryableAsync();
+            var eventRegistrationQueryable = dbContext.Set<EventRegistration>().AsQueryable();
+            var organizationQueryable = dbContext.Set<Organization>().AsQueryable();
+
+            var query = (from @event in eventQueryable
+                         join organization in organizationQueryable on @event.OrganizationId equals organization.Id
+                         select new
+                         {
+                             Event = @event,
+                             Organization = organization,
+                             AttendeeCount = (from eventRegistration in eventRegistrationQueryable
+                                              where eventRegistration.EventId == @event.Id
+                                              select @eventRegistration).Count()
+                         })
+                     .WhereIf(!string.IsNullOrWhiteSpace(title), x => x.Event.Title.ToLower().Contains(title.ToLower()))
+                     .WhereIf(!string.IsNullOrWhiteSpace(organizationDisplayName), x => x.Organization.DisplayName.ToLower().Contains(organizationDisplayName.ToLower()))
+                     .WhereIf(minStartTime.HasValue, x => x.Event.StartTime >= minStartTime)
+                     .WhereIf(maxStartTime.HasValue, x => x.Event.StartTime <= maxStartTime)
+                     .WhereIf(minAttendeeCount.HasValue, x => x.AttendeeCount >= minAttendeeCount)
+                     .WhereIf(maxAttendeeCount.HasValue, x => x.AttendeeCount <= maxAttendeeCount);
+
+            return await query.CountAsync(GetCancellationToken(cancellationToken));
+        }
+
+        public async Task<List<EventWithDetails>> GetListAsync(
+            string sorting = null,
+            int skipCount = 0, 
+            int maxResultCount = int.MaxValue, 
+            string title = null, 
+            string organizationDisplayName = null, 
+            int? minAttendeeCount = null, 
+            int? maxAttendeeCount = null, 
+            DateTime? minStartTime = null, 
+            DateTime? maxStartTime = null, 
+            CancellationToken cancellationToken = default
+        )
+        {
+            var dbContext = await GetDbContextAsync();
+
+            var eventQueryable = await GetQueryableAsync();
+            var eventRegistrationQueryable = dbContext.Set<EventRegistration>().AsQueryable();
+            var organizationQueryable = dbContext.Set<Organization>().AsQueryable();
+
+            var query = (from @event in eventQueryable
+                    join organization in organizationQueryable on @event.OrganizationId equals organization.Id
+                    select new EventWithDetails
+                    {
+                        Id = @event.Id,
+                        Title = @event.Title,
+                        StartTime = @event.StartTime,
+                        OrganizationDisplayName = organization.DisplayName,
+                        AttendeeCount = (from eventRegistration in eventRegistrationQueryable
+                            where eventRegistration.EventId == @event.Id
+                            select @eventRegistration).Count()
+                    })
+                .WhereIf(!string.IsNullOrWhiteSpace(title), x => x.Title.ToLower().Contains(title.ToLower()))
+                .WhereIf(!string.IsNullOrWhiteSpace(organizationDisplayName),
+                    x => x.OrganizationDisplayName.ToLower().Contains(organizationDisplayName.ToLower()))
+                .WhereIf(minStartTime.HasValue, x => x.StartTime >= minStartTime)
+                .WhereIf(maxStartTime.HasValue, x => x.StartTime <= maxStartTime)
+                .WhereIf(minAttendeeCount.HasValue, x => x.AttendeeCount >= minAttendeeCount)
+                .WhereIf(maxAttendeeCount.HasValue, x => x.AttendeeCount <= maxAttendeeCount)
+                .OrderBy(string.IsNullOrWhiteSpace(sorting) ? EventConsts.DefaultSorting : sorting)
+                .PageBy(skipCount, maxResultCount);
+
+            return await query.ToListAsync(GetCancellationToken(cancellationToken));
+        }
+    }
+}

src/EventHub.EntityFrameworkCore/EntityFrameworkCore/Events/Registrations/EventRegistrationRepository.cs

@@ -0,0 +1,61 @@
+using EventHub.Events.Registrations;
+using System;
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Identity;
+
+namespace EventHub.EntityFrameworkCore.Events.Registrations
+{
+    public class EventRegistrationRepository : EfCoreRepository<EventHubDbContext, EventRegistration, Guid>, IEventRegistrationRepository
+    {
+        public EventRegistrationRepository(IDbContextProvider<EventHubDbContext> dbContextProvider) : base(dbContextProvider)
+        {
+        }
+
+        public async Task<int> GetCountAsync(Guid eventId, CancellationToken cancellationToken = default)
+        {
+            var userQueryable = (await GetDbContextAsync()).Set<IdentityUser>().AsQueryable();
+
+            var query = from eventRegistration in (await GetQueryableAsync())
+                        join user in userQueryable on eventRegistration.UserId equals user.Id
+                        where eventRegistration.EventId == eventId
+                        select user;
+
+            return await query.CountAsync(GetCancellationToken(cancellationToken));
+        }
+
+        public async Task<List<EventRegistrationWithDetails>> GetListAsync(
+            Guid eventId,
+            string sorting = null,
+            int skipCount = 0,
+            int maxResultCount = int.MaxValue,
+            CancellationToken cancellationToken = default
+        )
+        {
+            var userQueryable = (await GetDbContextAsync()).Set<IdentityUser>().AsQueryable();
+
+            var query = (from eventRegistration in (await GetQueryableAsync())
+                join user in userQueryable on eventRegistration.UserId equals user.Id
+                where eventRegistration.EventId == eventId
+                select new EventRegistrationWithDetails
+                {
+                    UserId = user.Id,
+                    Name = user.Name,
+                    Surname = user.Surname,
+                    UserName = user.UserName,
+                    Email = user.Email,
+                    CreationTime = user.CreationTime
+                })
+                .OrderBy(string.IsNullOrWhiteSpace(sorting) ? nameof(EventRegistrationWithDetails.CreationTime) : sorting)
+                .PageBy(skipCount, maxResultCount);
+
+            return await query.ToListAsync(GetCancellationToken(cancellationToken));
+        }
+    }
+}

src/EventHub.EntityFrameworkCore/EntityFrameworkCore/Users/UserRepository.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using System.Threading;
+using System.Threading.Tasks;
+using EventHub.Users;
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Identity;
+
+namespace EventHub.EntityFrameworkCore.Users
+{
+    public class UserRepository : EfCoreRepository<EventHubDbContext, IdentityUser, Guid>, IUserRepository
+    {
+        public UserRepository(IDbContextProvider<EventHubDbContext> dbContextProvider) : base(dbContextProvider)
+        {
+        }
+
+        public async Task<int> GetCountAsync(string username = null, CancellationToken cancellationToken = default)
+        {
+            return await (await GetQueryableAsync())
+                .WhereIf(!string.IsNullOrWhiteSpace(username), user => user.UserName.ToLower().Contains(username.ToLower()))
+                .CountAsync(GetCancellationToken(cancellationToken));
+        }
+
+        public async Task<List<IdentityUser>> GetListAsync(
+            string sorting = null, 
+            int skipCount = 0, 
+            int maxResultCount = int.MaxValue, 
+            string username = null, 
+            CancellationToken cancellationToken = default
+        )
+        {
+            return await (await GetQueryableAsync())
+                .WhereIf(!string.IsNullOrWhiteSpace(username), user => user.UserName.ToLower().Contains(username.ToLower()))
+                .OrderBy(string.IsNullOrWhiteSpace(sorting) ? nameof(IdentityUser.CreationTime) : sorting)
+                .PageBy(skipCount, maxResultCount)
+                .ToListAsync(GetCancellationToken(cancellationToken));
+        }
+    }
+}