Merge remote-tracking branch 'origin/master' into feature/oauth

# Conflicts:
#	src/Web/Endpoints/Users.cs

src/Application/Users/Queries/GetMinimalUser/GetMinimalUser.cs

@@ -1,10 +1,12 @@
 using Hutopy.Application.Common.Interfaces;
+using Hutopy.Application.Common.Models;
 
 namespace Hutopy.Application.Users.Queries.GetMinimalUser;
 
 public record GetMinimalUserQuery : IRequest<MinimalUserDto>
 {
-    public string UserId { get; set; } = string.Empty;
+    public string? UserId { get; set; } = string.Empty;
+    public string? UserName { get; set; } = string.Empty;
 };
 
 public class GetMinimalUserQueryHandler(
@@ -14,13 +16,25 @@ public class GetMinimalUserQueryHandler(
 {
     public async Task<MinimalUserDto> Handle(GetMinimalUserQuery request, CancellationToken cancellationToken)
     {
-        var identityUser = await identityService.FindUserByIdAsync(request.UserId);
+        UserModel? identityUser = null;
+
+        if (request.UserId != string.Empty)
+        {
+            identityUser = await identityService.FindUserByIdAsync(request.UserId);
+
+        }
+
+        if (request.UserName != string.Empty)
+        {
+            identityUser = await identityService.GetUserByUserNameAsync(request.UserName);
+        }
+
 
         var user = new MinimalUserDto
         {
-            FirstName = identityUser?.FirstName ?? "",
+            FirstName = identityUser?.FirstName ?? string.Empty,
-            LastName = identityUser?.LastName ?? "",
+            LastName = identityUser?.LastName ?? string.Empty,
-            UserName = identityUser?.UserName ?? ""
+            UserName = identityUser?.UserName ?? string.Empty
         };
 
         return user;

src/Application/Users/Queries/GetMinimalUser/MinimalUserDto.cs

@@ -4,5 +4,5 @@ public class MinimalUserDto
 {
     public required string FirstName { get; init; }
     public required string LastName { get; init; }
-    public string UserName { get; init; } = String.Empty;
+    public required string UserName { get; init; } = String.Empty;
 }

src/Infrastructure/Data/ApplicationDbContext.cs

@@ -5,28 +5,24 @@ using Hutopy.Infrastructure.Identity;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 
-namespace Hutopy.Infrastructure.Data;
+namespace Hutopy.Infrastructure.Data
-
-public class ApplicationDbContext(
-    DbContextOptions<ApplicationDbContext> options)
-    : IdentityDbContext<ApplicationUser>(options), IApplicationDbContext
 {
-    public DbSet<FutureCreator> FutureCreators => Set<FutureCreator>();
+    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>, IApplicationDbContext
-    public DbSet<UserTransaction> UserTransactions => Set<UserTransaction>();
-
-    protected override void OnModelCreating(ModelBuilder builder)
     {
-        base.OnModelCreating(builder);
+        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
+            : base(options)
+        {
+        }
         
-        // Relationship between ApplicationUser and UserTransaction
+        public DbSet<FutureCreator> FutureCreators => Set<FutureCreator>();
-        builder.Entity<UserTransaction>()
+        public DbSet<UserTransaction> UserTransactions => Set<UserTransaction>();
-            .HasOne<ApplicationUser>()
-            .WithMany()
-            .HasForeignKey(ut => ut.ApplicationUserId)
-            .IsRequired();
 
-        builder.Entity<UserTransaction>().Property(x => x.Amount).HasPrecision(18, 2);
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            base.OnModelCreating(builder);
 
-        builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
+            // Apply configurations
+            builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
+        }
     }
 }

src/Infrastructure/Data/Configurations/ApplicationUserConfiguration.cs

@@ -0,0 +1,16 @@
+using Hutopy.Infrastructure.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Hutopy.Infrastructure.Data.Configurations;
+
+public class ApplicationUserConfiguration : IEntityTypeConfiguration<ApplicationUser>
+{
+    public void Configure(EntityTypeBuilder<ApplicationUser> builder)
+    {
+        // Relationship between ApplicationUser and SocialNetworks
+        builder
+            .OwnsOne(u => u.SocialNetworks)
+            .ToTable($"{nameof(ApplicationUser)}_SocialNetworks");
+    }
+}

src/Infrastructure/Data/Configurations/UserTransactionConfiguration.cs

@@ -0,0 +1,21 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Hutopy.Domain.Entities;
+using Hutopy.Infrastructure.Identity;
+
+namespace Hutopy.Infrastructure.Data.Configurations
+{
+    public class UserTransactionConfiguration : IEntityTypeConfiguration<UserTransaction>
+    {
+        public void Configure(EntityTypeBuilder<UserTransaction> builder)
+        {
+            // Relationship between ApplicationUser and UserTransaction
+            builder.HasOne<ApplicationUser>()
+                .WithMany()
+                .HasForeignKey(ut => ut.ApplicationUserId)
+                .IsRequired();
+
+            builder.Property(x => x.Amount).HasPrecision(18, 2);
+        }
+    }
+}

src/Infrastructure/Identity/ApplicationUser.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Identity;
+using Hutopy.Infrastructure.Identity.OwnedEntities;
+using Microsoft.AspNetCore.Identity;
 
 namespace Hutopy.Infrastructure.Identity;
 
@@ -6,4 +7,5 @@ public class ApplicationUser : IdentityUser
 {
     public string FirstName { get; set; } = string.Empty;
     public string LastName { get; set; } = string.Empty;
+    public SocialNetworks SocialNetworks { get; set; } = new();
 }

src/Infrastructure/Identity/OwnedEntities/SocialNetworks.cs

@@ -0,0 +1,13 @@
+namespace Hutopy.Infrastructure.Identity.OwnedEntities;
+
+public class SocialNetworks
+{
+    public string FacebookUrl { get; init; } = String.Empty;
+    public string InstagramUrl { get; init; } = String.Empty;
+    public string XUrl { get; init; } = String.Empty;
+    public string LinkedInUrl { get; init; } = String.Empty;
+    public string TikTokUrl { get; init; } = String.Empty;
+    public string YoutubeUrl { get; init; } = String.Empty;
+    public string RedditUrl { get; init; } = String.Empty;
+    public string YourWebsiteUrl { get; init; } = String.Empty;
+}

src/Infrastructure/Migrations/20240612000806_AddSocialNetworksToUser.Designer.cs

@@ -0,0 +1,469 @@
+// <auto-generated />
+using System;
+using Hutopy.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240612000806_AddSocialNetworksToUser")]
+    partial class AddSocialNetworksToUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.FutureCreator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReasonToJoin")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SocialNetworkAccount")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FutureCreators");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.UserTransaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ApplicationUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Paid")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("StripeBillingDetailEmail")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripeBillingDetailName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripeChargeId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripeEventId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripePaymentIntent")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripePaymentMethod")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StripeReceiptUrl")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TipMessage")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("UserTransactions");
+                });
+
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.UserTransaction", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.OwnsOne("Hutopy.Infrastructure.Identity.OwnedEntities.SocialNetworks", "SocialNetworks", b1 =>
+                        {
+                            b1.Property<string>("ApplicationUserId")
+                                .HasColumnType("nvarchar(450)");
+
+                            b1.Property<string>("FacebookUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("InstagramUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("LinkedInUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("RedditUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("TikTokUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("XUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("YourWebsiteUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("YoutubeUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("ApplicationUserId");
+
+                            b1.ToTable("ApplicationUser_SocialNetworks", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("ApplicationUserId");
+                        });
+
+                    b.Navigation("SocialNetworks")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Infrastructure/Migrations/20240612000806_AddSocialNetworksToUser.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSocialNetworksToUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ApplicationUser_SocialNetworks",
+                columns: table => new
+                {
+                    ApplicationUserId = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    FacebookUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    InstagramUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    XUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    LinkedInUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    TikTokUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    YoutubeUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    RedditUrl = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    YourWebsiteUrl = table.Column<string>(type: "nvarchar(max)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ApplicationUser_SocialNetworks", x => x.ApplicationUserId);
+                    table.ForeignKey(
+                        name: "FK_ApplicationUser_SocialNetworks_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+            
+                migrationBuilder.Sql(@"
+                    INSERT INTO ApplicationUser_SocialNetworks (ApplicationUserId, FacebookUrl, InstagramUrl, XUrl, LinkedInUrl, TikTokUrl, YoutubeUrl, RedditUrl, YourWebsiteUrl)
+                    SELECT Id, '', '', '', '', '', '', '', ''
+                    FROM AspNetUsers
+                ");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ApplicationUser_SocialNetworks");
+        }
+    }
+}

src/Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -359,6 +359,57 @@ namespace Hutopy.Infrastructure.Migrations
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.OwnsOne("Hutopy.Infrastructure.Identity.OwnedEntities.SocialNetworks", "SocialNetworks", b1 =>
+                        {
+                            b1.Property<string>("ApplicationUserId")
+                                .HasColumnType("nvarchar(450)");
+
+                            b1.Property<string>("FacebookUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("InstagramUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("LinkedInUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("RedditUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("TikTokUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("XUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("YourWebsiteUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("YoutubeUrl")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("ApplicationUserId");
+
+                            b1.ToTable("ApplicationUser_SocialNetworks", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("ApplicationUserId");
+                        });
+
+                    b.Navigation("SocialNetworks")
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)

src/Infrastructure/Stripe/StripeService.cs

@@ -4,6 +4,7 @@ using Hutopy.Application.Common.Interfaces;
 using Microsoft.AspNetCore.Http;
 using Hutopy.Application.Common.Models;
 using Hutopy.Application.Stripe.Commands;
+using Microsoft.Extensions.Configuration;
 
 namespace Hutopy.Infrastructure.Stripe;
 
@@ -11,10 +12,11 @@ public class StripeService : IStripeService
 {
     private readonly IHttpContextAccessor _httpContextAccessor;
 
-    public StripeService(IHttpContextAccessor httpContextAccessor)
+    public StripeService(IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
     {
         _httpContextAccessor = httpContextAccessor;
-        StripeConfiguration.ApiKey = "";
+        var stripeKey = configuration["STRIPE-API-KEY"] ?? "";
+        StripeConfiguration.ApiKey = stripeKey;
     }
 
   public async Task<string> CreateCheckoutSession(int amount, string creatorId, string currency = "cad")

src/Web/wwwroot/api/specification.json

@@ -251,12 +251,20 @@
           {
             "name": "UserId",
             "in": "query",
-            "required": true,
             "schema": {
               "type": "string",
               "nullable": true
             },
             "x-position": 1
+          },
+          {
+            "name": "UserName",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "nullable": true
+            },
+            "x-position": 2
           }
         ],
         "responses": {