Added EventRegistration.

eventhub/src/EventHub.Domain/Events/Registrations/EventRegistration.cs

@@ -0,0 +1,27 @@
+using System;
+using Volo.Abp.Domain.Entities.Auditing;
+
+namespace EventHub.Events.Registrations
+{
+    public class EventRegistration : CreationAuditedAggregateRoot<Guid>
+    {
+        public Guid EventId { get; private set; }
+
+        public Guid UserId { get; private set; }
+
+        private EventRegistration()
+        {
+
+        }
+
+        public EventRegistration(
+            Guid id,
+            Guid eventId,
+            Guid userId)
+            : base(id)
+        {
+            EventId = eventId;
+            UserId = userId;
+        }
+    }
+}

eventhub/src/EventHub.Domain/Events/Registrations/EventRegistrationManager.cs

@@ -0,0 +1,18 @@
+using System;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Domain.Services;
+
+namespace EventHub.Events.Registrations
+{
+    public class EventRegistrationManager : DomainService
+    {
+        private readonly IRepository<EventRegistration, Guid> _eventRegistrationRepository;
+
+        public EventRegistrationManager(
+            IRepository<EventRegistration, Guid> eventRegistrationRepository
+            )
+        {
+            _eventRegistrationRepository = eventRegistrationRepository;
+        }
+    }
+}

eventhub/src/EventHub.EntityFrameworkCore.DbMigrations/EntityFrameworkCore/EventHubMigrationsDbContext.cs

@@ -1,7 +1,9 @@
-using Microsoft.EntityFrameworkCore;
+using EventHub.Events.Registrations;
+using Microsoft.EntityFrameworkCore;
 using Volo.Abp.AuditLogging.EntityFrameworkCore;
 using Volo.Abp.BackgroundJobs.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Identity;
 using Volo.Abp.Identity.EntityFrameworkCore;
 using Volo.Abp.IdentityServer.EntityFrameworkCore;
 using Volo.Abp.PermissionManagement.EntityFrameworkCore;
@@ -37,7 +39,7 @@ namespace EventHub.EntityFrameworkCore
 
             /* Configure your own tables/entities inside the ConfigureEventHub method */
 
-            builder.ConfigureEventHub();
+            builder.ConfigureEventHub(true);
         }
     }
 }

eventhub/src/EventHub.EntityFrameworkCore.DbMigrations/Migrations/20210124142029_Added_EventRegistration.cs

@@ -0,0 +1,85 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace EventHub.Migrations
+{
+    public partial class Added_EventRegistration : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "AppEventRegistrations",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    EventId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    ExtraProperties = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    ConcurrencyStamp = table.Column<string>(type: "nvarchar(40)", maxLength: 40, nullable: true),
+                    CreationTime = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    CreatorId = table.Column<Guid>(type: "uniqueidentifier", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AppEventRegistrations", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AppEventRegistrations_AbpUsers_UserId",
+                        column: x => x.UserId,
+                        principalTable: "AbpUsers",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_AppEventRegistrations_AppEvents_EventId",
+                        column: x => x.EventId,
+                        principalTable: "AppEvents",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AppOrganizations_OwnerUserId",
+                table: "AppOrganizations",
+                column: "OwnerUserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AppEventRegistrations_EventId_UserId",
+                table: "AppEventRegistrations",
+                columns: new[] { "EventId", "UserId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AppEventRegistrations_UserId",
+                table: "AppEventRegistrations",
+                column: "UserId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AppEvents_AppOrganizations_OrganizationId",
+                table: "AppEvents",
+                column: "OrganizationId",
+                principalTable: "AppOrganizations",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AppOrganizations_AbpUsers_OwnerUserId",
+                table: "AppOrganizations",
+                column: "OwnerUserId",
+                principalTable: "AbpUsers",
+                principalColumn: "Id");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AppEvents_AppOrganizations_OrganizationId",
+                table: "AppEvents");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AppOrganizations_AbpUsers_OwnerUserId",
+                table: "AppOrganizations");
+
+            migrationBuilder.DropTable(
+                name: "AppEventRegistrations");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AppOrganizations_OwnerUserId",
+                table: "AppOrganizations");
+        }
+    }
+}

eventhub/src/EventHub.EntityFrameworkCore.DbMigrations/Migrations/EventHubMigrationsDbContextModelSnapshot.cs

@@ -113,6 +113,45 @@ namespace EventHub.Migrations
                     b.ToTable("AppEvents");
                 });
 
+            modelBuilder.Entity("EventHub.Events.Registrations.EventRegistration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("nvarchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EventId", "UserId");
+
+                    b.ToTable("AppEventRegistrations");
+                });
+
             modelBuilder.Entity("EventHub.Organizations.Organization", b =>
                 {
                     b.Property<Guid>("Id")
@@ -201,6 +240,8 @@ namespace EventHub.Migrations
 
                     b.HasIndex("Name");
 
+                    b.HasIndex("OwnerUserId");
+
                     b.ToTable("AppOrganizations");
                 });
 
@@ -2012,6 +2053,39 @@ namespace EventHub.Migrations
                     b.ToTable("AbpSettings");
                 });
 
+            modelBuilder.Entity("EventHub.Events.Event", b =>
+                {
+                    b.HasOne("EventHub.Organizations.Organization", null)
+                        .WithMany()
+                        .HasForeignKey("OrganizationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("EventHub.Events.Registrations.EventRegistration", b =>
+                {
+                    b.HasOne("EventHub.Events.Event", null)
+                        .WithMany()
+                        .HasForeignKey("EventId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("EventHub.Organizations.Organization", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("OwnerUserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLogAction", b =>
                 {
                     b.HasOne("Volo.Abp.AuditLogging.AuditLog", null)

eventhub/src/EventHub.EntityFrameworkCore/EntityFrameworkCore/EventHubDbContext.cs

@@ -1,4 +1,5 @@
 using EventHub.Events;
+using EventHub.Events.Registrations;
 using EventHub.Organizations;
 using Microsoft.EntityFrameworkCore;
 using EventHub.Users;
@@ -25,6 +26,7 @@ namespace EventHub.EntityFrameworkCore
         public DbSet<AppUser> Users { get; set; }
         public DbSet<Organization> Organizations { get; set; }
         public DbSet<Event> Events { get; set; }
+        public DbSet<EventRegistration> EventRegistrations { get; set; }
 
         public EventHubDbContext(DbContextOptions<EventHubDbContext> options)
             : base(options)
@@ -52,7 +54,7 @@ namespace EventHub.EntityFrameworkCore
 
             /* Configure your own tables/entities inside the ConfigureEventHub method */
 
-            builder.ConfigureEventHub();
+            builder.ConfigureEventHub(false);
         }
     }
 }

eventhub/src/EventHub.EntityFrameworkCore/EntityFrameworkCore/EventHubDbContextModelCreatingExtensions.cs

@@ -1,14 +1,18 @@
 using EventHub.Events;
+using EventHub.Events.Registrations;
 using EventHub.Organizations;
 using Microsoft.EntityFrameworkCore;
 using Volo.Abp;
 using Volo.Abp.EntityFrameworkCore.Modeling;
+using Volo.Abp.Identity;
 
 namespace EventHub.EntityFrameworkCore
 {
     public static class EventHubDbContextModelCreatingExtensions
     {
-        public static void ConfigureEventHub(this ModelBuilder builder)
+        public static void ConfigureEventHub(
+            this ModelBuilder builder,
+            bool isMigrationDbContext)
         {
             Check.NotNull(builder, nameof(builder));
 
@@ -24,6 +28,11 @@ namespace EventHub.EntityFrameworkCore
                 b.Property(x => x.DisplayName).IsRequired().HasMaxLength(OrganizationConsts.MaxDisplayNameLength);
                 b.Property(x => x.Description).IsRequired().HasMaxLength(OrganizationConsts.MaxDescriptionNameLength);
 
+                if (isMigrationDbContext)
+                {
+                    b.HasOne<IdentityUser>().WithMany().HasForeignKey(x => x.OwnerUserId).IsRequired().OnDelete(DeleteBehavior.NoAction);
+                }
+
                 b.HasIndex(x => x.Name);
                 b.HasIndex(x => x.DisplayName);
             });
@@ -39,10 +48,28 @@ namespace EventHub.EntityFrameworkCore
                 b.Property(x => x.UrlCode).IsRequired().HasMaxLength(EventConsts.UrlCodeLength);
                 b.Property(x => x.Url).IsRequired().HasMaxLength(EventConsts.MaxUrlLength);
 
+                b.HasOne<Organization>().WithMany().HasForeignKey(x => x.OrganizationId).IsRequired().OnDelete(DeleteBehavior.NoAction);
+
                 b.HasIndex(x => new {x.OrganizationId, x.StartTime});
                 b.HasIndex(x => x.StartTime);
                 b.HasIndex(x => x.UrlCode);
             });
+
+            builder.Entity<EventRegistration>(b =>
+            {
+                b.ToTable(EventHubConsts.DbTablePrefix + "EventRegistrations", EventHubConsts.DbSchema);
+
+                b.ConfigureByConvention();
+
+                b.HasOne<Event>().WithMany().HasForeignKey(x => x.EventId).IsRequired().OnDelete(DeleteBehavior.NoAction);
+
+                if (isMigrationDbContext)
+                {
+                    b.HasOne<IdentityUser>().WithMany().HasForeignKey(x => x.UserId).IsRequired().OnDelete(DeleteBehavior.NoAction);
+                }
+
+                b.HasIndex(x => new {x.EventId, x.UserId});
+            });
         }
     }
 }

eventhub/src/EventHub.Web/Pages/Events/Components/RegistrationArea/RegistrationAreaViewComponent.cs

@@ -0,0 +1,9 @@
+using Volo.Abp.AspNetCore.Mvc;
+
+namespace EventHub.Web.Pages.Events.Components.RegistrationArea
+{
+    public class RegistrationAreaViewComponent : AbpViewComponent
+    {
+        
+    }
+}

eventhub/test/EventHub.TestBase/EventHubTestData.cs

@@ -5,6 +5,14 @@ namespace EventHub
 {
     public class EventHubTestData : ISingletonDependency
     {
+        /* USERS *************************************************************/
+
+        public Guid UserAdminId { get; internal set; }
+        public string UserAdminUserName { get; } = "admin";
+
+        public Guid UserJohnId { get; } = Guid.NewGuid();
+        public string UserJohnUserName { get; } = "john";
+
         /* ORGANIZATIONS *****************************************************/
 
         public Guid OrganizationVolosoftId { get; } = Guid.NewGuid();

eventhub/test/EventHub.TestBase/EventHubTestDataSeedContributor.cs

@@ -5,8 +5,8 @@ using EventHub.Organizations;
 using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Identity;
 using Volo.Abp.Timing;
-using Volo.Abp.Users;
 
 namespace EventHub
 {
@@ -14,28 +14,43 @@ namespace EventHub
     {
         private readonly IRepository<Organization, Guid> _organizationRepository;
         private readonly IRepository<Event, Guid> _eventRepository;
-        private readonly ICurrentUser _currentUser;
         private readonly EventHubTestData _eventHubTestData;
         private readonly IClock _clock;
+        private readonly IIdentityUserRepository _userRepository;
 
         public EventHubTestDataSeedContributor(
             EventHubTestData eventHubTestData,
-            ICurrentUser currentUser,
             IRepository<Organization, Guid> organizationRepository,
             IRepository<Event, Guid> eventRepository,
-            IClock clock)
+            IClock clock,
+            IIdentityUserRepository userRepository)
         {
             _eventHubTestData = eventHubTestData;
-            _currentUser = currentUser;
             _organizationRepository = organizationRepository;
             _eventRepository = eventRepository;
             _clock = clock;
+            _userRepository = userRepository;
         }
 
         public async Task SeedAsync(DataSeedContext context)
         {
+            await CreateUsersAsync();
             await CreateOrganizationsAsync();
-            await CreateEvents();
+            await CreateEventsAsync();
+        }
+
+        private async Task CreateUsersAsync()
+        {
+            var adminUser = await _userRepository.FindByNormalizedUserNameAsync("ADMIN");
+            _eventHubTestData.UserAdminId = adminUser.Id;
+
+            await _userRepository.InsertAsync(
+                new IdentityUser(
+                    _eventHubTestData.UserJohnId,
+                    _eventHubTestData.UserJohnUserName,
+                    "john@abp.io"
+                )
+            );
         }
 
         private async Task CreateOrganizationsAsync()
@@ -43,7 +58,7 @@ namespace EventHub
             await _organizationRepository.InsertAsync(
                 new Organization(
                     _eventHubTestData.OrganizationVolosoftId,
-                    _currentUser.GetId(),
+                    _eventHubTestData.UserAdminId,
                     _eventHubTestData.OrganizationVolosoftName,
                     "Volosoft",
                     "Volosoft is producing software development tools for developers. We are organizing events related to the ABP.IO platform and general software development topic."
@@ -53,7 +68,7 @@ namespace EventHub
             await _organizationRepository.InsertAsync(
                 new Organization(
                     _eventHubTestData.OrganizationDotnetEuropeId,
-                    Guid.NewGuid(),
+                    _eventHubTestData.UserJohnId,
                     _eventHubTestData.OrganizationDotnetEuropeName,
                     "Dotnet Europe",
                     "Organizing events on Microsoft's .NET Platform in European Countries."
@@ -61,7 +76,7 @@ namespace EventHub
             );
         }
 
-        private async Task CreateEvents()
+        private async Task CreateEventsAsync()
         {
             await _eventRepository.InsertAsync(
                 new Event(

eventhub/test/EventHub.TestBase/Security/FakeCurrentPrincipalAccessor.cs

@@ -8,36 +8,30 @@ namespace EventHub.Security
     [Dependency(ReplaceServices = true)]
     public class FakeCurrentPrincipalAccessor : ThreadCurrentPrincipalAccessor
     {
+        private readonly EventHubTestData _eventHubTestData;
+
+        public FakeCurrentPrincipalAccessor(EventHubTestData eventHubTestData)
+        {
+            _eventHubTestData = eventHubTestData;
+        }
+
         protected override ClaimsPrincipal GetClaimsPrincipal()
         {
             return GetPrincipal();
         }
 
-        private ClaimsPrincipal _principal;
-
         private ClaimsPrincipal GetPrincipal()
         {
-            if (_principal == null)
-            {
-                lock (this)
-                {
-                    if (_principal == null)
+            return new ClaimsPrincipal(
+                new ClaimsIdentity(
+                    new List<Claim>
                     {
-                        _principal = new ClaimsPrincipal(
-                            new ClaimsIdentity(
-                                new List<Claim>
-                                {
-                                    new Claim(AbpClaimTypes.UserId,"2e701e62-0953-4dd3-910b-dc6cc93ccb0d"),
-                                    new Claim(AbpClaimTypes.UserName,"admin"),
-                                    new Claim(AbpClaimTypes.Email,"admin@abp.io")
-                                }
-                            )
-                        );
+                        new Claim(AbpClaimTypes.UserId,_eventHubTestData.UserAdminId.ToString()),
+                        new Claim(AbpClaimTypes.UserName,_eventHubTestData.UserAdminUserName),
+                        new Claim(AbpClaimTypes.Email,"admin@abp.io")
                     }
-                }
-            }
-
-            return _principal;
+                )
+            );
         }
     }
 }