< Summary

Information
Class: OzonRepositories.Migrations.OzonIdentityOrder.Baseline
Assembly: OzonRepositories
File(s): File 1: /home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Migrations/OzonIdentityOrder/20260908110100_Baseline.cs
File 2: /home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Migrations/OzonIdentityOrder/20260908110100_Baseline.Designer.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 643
Coverable lines: 643
Total lines: 729
Line coverage: 0%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
File 1: Up(...)100%210%
File 1: Down(...)100%210%
File 2: BuildTargetModel(...)100%210%

File(s)

/home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Migrations/OzonIdentityOrder/20260908110100_Baseline.cs

#LineLine coverage
 1using System;
 2using Microsoft.EntityFrameworkCore.Metadata;
 3using Microsoft.EntityFrameworkCore.Migrations;
 4
 5#nullable disable
 6
 7namespace OzonRepositories.Migrations.OzonIdentityOrder
 8{
 9    /// <inheritdoc />
 10    public partial class Baseline : Migration
 11    {
 12        /// <inheritdoc />
 13        protected override void Up(MigrationBuilder migrationBuilder)
 14        {
 015            migrationBuilder.AlterDatabase()
 016                .Annotation("MySql:CharSet", "utf8mb4");
 17
 018            migrationBuilder.CreateTable(
 019                name: "AspNetRoles",
 020                columns: table => new
 021                {
 022                    Id = table.Column<string>(type: "varchar(255)", nullable: false)
 023                        .Annotation("MySql:CharSet", "utf8mb4"),
 024                    Name = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 025                        .Annotation("MySql:CharSet", "utf8mb4"),
 026                    NormalizedName = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 027                        .Annotation("MySql:CharSet", "utf8mb4"),
 028                    ConcurrencyStamp = table.Column<string>(type: "longtext", nullable: true)
 029                        .Annotation("MySql:CharSet", "utf8mb4")
 030                },
 031                constraints: table =>
 032                {
 033                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
 034                })
 035                .Annotation("MySql:CharSet", "utf8mb4");
 36
 037            migrationBuilder.CreateTable(
 038                name: "AspNetUsers",
 039                columns: table => new
 040                {
 041                    Id = table.Column<string>(type: "varchar(255)", nullable: false)
 042                        .Annotation("MySql:CharSet", "utf8mb4"),
 043                    AccessProfileId = table.Column<int>(type: "int", nullable: true),
 044                    IsAdminApproved = table.Column<bool>(type: "tinyint(1)", nullable: false),
 045                    AdminApprovedAtUtc = table.Column<DateTime>(type: "datetime(6)", nullable: true),
 046                    AdminApprovedBy = table.Column<string>(type: "longtext", nullable: true)
 047                        .Annotation("MySql:CharSet", "utf8mb4"),
 048                    GoogleDisplayName = table.Column<string>(type: "longtext", nullable: true)
 049                        .Annotation("MySql:CharSet", "utf8mb4"),
 050                    GoogleAvatarUrl = table.Column<string>(type: "longtext", nullable: true)
 051                        .Annotation("MySql:CharSet", "utf8mb4"),
 052                    Discriminator = table.Column<string>(type: "varchar(21)", maxLength: 21, nullable: false)
 053                        .Annotation("MySql:CharSet", "utf8mb4"),
 054                    UserName = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 055                        .Annotation("MySql:CharSet", "utf8mb4"),
 056                    NormalizedUserName = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 057                        .Annotation("MySql:CharSet", "utf8mb4"),
 058                    Email = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 059                        .Annotation("MySql:CharSet", "utf8mb4"),
 060                    NormalizedEmail = table.Column<string>(type: "varchar(256)", maxLength: 256, nullable: true)
 061                        .Annotation("MySql:CharSet", "utf8mb4"),
 062                    EmailConfirmed = table.Column<bool>(type: "tinyint(1)", nullable: false),
 063                    PasswordHash = table.Column<string>(type: "longtext", nullable: true)
 064                        .Annotation("MySql:CharSet", "utf8mb4"),
 065                    SecurityStamp = table.Column<string>(type: "longtext", nullable: true)
 066                        .Annotation("MySql:CharSet", "utf8mb4"),
 067                    ConcurrencyStamp = table.Column<string>(type: "longtext", nullable: true)
 068                        .Annotation("MySql:CharSet", "utf8mb4"),
 069                    PhoneNumber = table.Column<string>(type: "longtext", nullable: true)
 070                        .Annotation("MySql:CharSet", "utf8mb4"),
 071                    PhoneNumberConfirmed = table.Column<bool>(type: "tinyint(1)", nullable: false),
 072                    TwoFactorEnabled = table.Column<bool>(type: "tinyint(1)", nullable: false),
 073                    LockoutEnd = table.Column<DateTimeOffset>(type: "datetime(6)", nullable: true),
 074                    LockoutEnabled = table.Column<bool>(type: "tinyint(1)", nullable: false),
 075                    AccessFailedCount = table.Column<int>(type: "int", nullable: false)
 076                },
 077                constraints: table =>
 078                {
 079                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
 080                    table.ForeignKey(
 081                        name: "FK_AspNetUsers_AccessProfiles_AccessProfileId",
 082                        column: x => x.AccessProfileId,
 083                        principalTable: "AccessProfiles",
 084                        principalColumn: "Id",
 085                        onDelete: ReferentialAction.SetNull);
 086                })
 087                .Annotation("MySql:CharSet", "utf8mb4");
 88
 089            migrationBuilder.CreateTable(
 090                name: "AspNetRoleClaims",
 091                columns: table => new
 092                {
 093                    Id = table.Column<int>(type: "int", nullable: false)
 094                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
 095                    RoleId = table.Column<string>(type: "varchar(255)", nullable: false)
 096                        .Annotation("MySql:CharSet", "utf8mb4"),
 097                    ClaimType = table.Column<string>(type: "longtext", nullable: true)
 098                        .Annotation("MySql:CharSet", "utf8mb4"),
 099                    ClaimValue = table.Column<string>(type: "longtext", nullable: true)
 0100                        .Annotation("MySql:CharSet", "utf8mb4")
 0101                },
 0102                constraints: table =>
 0103                {
 0104                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
 0105                    table.ForeignKey(
 0106                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
 0107                        column: x => x.RoleId,
 0108                        principalTable: "AspNetRoles",
 0109                        principalColumn: "Id",
 0110                        onDelete: ReferentialAction.Cascade);
 0111                })
 0112                .Annotation("MySql:CharSet", "utf8mb4");
 113
 0114            migrationBuilder.CreateTable(
 0115                name: "AspNetUserClaims",
 0116                columns: table => new
 0117                {
 0118                    Id = table.Column<int>(type: "int", nullable: false)
 0119                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
 0120                    UserId = table.Column<string>(type: "varchar(255)", nullable: false)
 0121                        .Annotation("MySql:CharSet", "utf8mb4"),
 0122                    ClaimType = table.Column<string>(type: "longtext", nullable: true)
 0123                        .Annotation("MySql:CharSet", "utf8mb4"),
 0124                    ClaimValue = table.Column<string>(type: "longtext", nullable: true)
 0125                        .Annotation("MySql:CharSet", "utf8mb4")
 0126                },
 0127                constraints: table =>
 0128                {
 0129                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
 0130                    table.ForeignKey(
 0131                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
 0132                        column: x => x.UserId,
 0133                        principalTable: "AspNetUsers",
 0134                        principalColumn: "Id",
 0135                        onDelete: ReferentialAction.Cascade);
 0136                })
 0137                .Annotation("MySql:CharSet", "utf8mb4");
 138
 0139            migrationBuilder.CreateTable(
 0140                name: "AspNetUserLogins",
 0141                columns: table => new
 0142                {
 0143                    LoginProvider = table.Column<string>(type: "varchar(128)", maxLength: 128, nullable: false)
 0144                        .Annotation("MySql:CharSet", "utf8mb4"),
 0145                    ProviderKey = table.Column<string>(type: "varchar(128)", maxLength: 128, nullable: false)
 0146                        .Annotation("MySql:CharSet", "utf8mb4"),
 0147                    ProviderDisplayName = table.Column<string>(type: "longtext", nullable: true)
 0148                        .Annotation("MySql:CharSet", "utf8mb4"),
 0149                    UserId = table.Column<string>(type: "varchar(255)", nullable: false)
 0150                        .Annotation("MySql:CharSet", "utf8mb4")
 0151                },
 0152                constraints: table =>
 0153                {
 0154                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
 0155                    table.ForeignKey(
 0156                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
 0157                        column: x => x.UserId,
 0158                        principalTable: "AspNetUsers",
 0159                        principalColumn: "Id",
 0160                        onDelete: ReferentialAction.Cascade);
 0161                })
 0162                .Annotation("MySql:CharSet", "utf8mb4");
 163
 0164            migrationBuilder.CreateTable(
 0165                name: "AspNetUserRoles",
 0166                columns: table => new
 0167                {
 0168                    UserId = table.Column<string>(type: "varchar(255)", nullable: false)
 0169                        .Annotation("MySql:CharSet", "utf8mb4"),
 0170                    RoleId = table.Column<string>(type: "varchar(255)", nullable: false)
 0171                        .Annotation("MySql:CharSet", "utf8mb4")
 0172                },
 0173                constraints: table =>
 0174                {
 0175                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
 0176                    table.ForeignKey(
 0177                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
 0178                        column: x => x.RoleId,
 0179                        principalTable: "AspNetRoles",
 0180                        principalColumn: "Id",
 0181                        onDelete: ReferentialAction.Cascade);
 0182                    table.ForeignKey(
 0183                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
 0184                        column: x => x.UserId,
 0185                        principalTable: "AspNetUsers",
 0186                        principalColumn: "Id",
 0187                        onDelete: ReferentialAction.Cascade);
 0188                })
 0189                .Annotation("MySql:CharSet", "utf8mb4");
 190
 0191            migrationBuilder.CreateTable(
 0192                name: "AspNetUserTokens",
 0193                columns: table => new
 0194                {
 0195                    UserId = table.Column<string>(type: "varchar(255)", nullable: false)
 0196                        .Annotation("MySql:CharSet", "utf8mb4"),
 0197                    LoginProvider = table.Column<string>(type: "varchar(128)", maxLength: 128, nullable: false)
 0198                        .Annotation("MySql:CharSet", "utf8mb4"),
 0199                    Name = table.Column<string>(type: "varchar(128)", maxLength: 128, nullable: false)
 0200                        .Annotation("MySql:CharSet", "utf8mb4"),
 0201                    Value = table.Column<string>(type: "longtext", nullable: true)
 0202                        .Annotation("MySql:CharSet", "utf8mb4")
 0203                },
 0204                constraints: table =>
 0205                {
 0206                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
 0207                    table.ForeignKey(
 0208                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
 0209                        column: x => x.UserId,
 0210                        principalTable: "AspNetUsers",
 0211                        principalColumn: "Id",
 0212                        onDelete: ReferentialAction.Cascade);
 0213                })
 0214                .Annotation("MySql:CharSet", "utf8mb4");
 215
 0216            migrationBuilder.CreateIndex(
 0217                name: "IX_AspNetRoleClaims_RoleId",
 0218                table: "AspNetRoleClaims",
 0219                column: "RoleId");
 220
 0221            migrationBuilder.CreateIndex(
 0222                name: "RoleNameIndex",
 0223                table: "AspNetRoles",
 0224                column: "NormalizedName",
 0225                unique: true);
 226
 0227            migrationBuilder.CreateIndex(
 0228                name: "IX_AspNetUserClaims_UserId",
 0229                table: "AspNetUserClaims",
 0230                column: "UserId");
 231
 0232            migrationBuilder.CreateIndex(
 0233                name: "IX_AspNetUserLogins_UserId",
 0234                table: "AspNetUserLogins",
 0235                column: "UserId");
 236
 0237            migrationBuilder.CreateIndex(
 0238                name: "IX_AspNetUserRoles_RoleId",
 0239                table: "AspNetUserRoles",
 0240                column: "RoleId");
 241
 0242            migrationBuilder.CreateIndex(
 0243                name: "EmailIndex",
 0244                table: "AspNetUsers",
 0245                column: "NormalizedEmail");
 246
 0247            migrationBuilder.CreateIndex(
 0248                name: "IX_AspNetUsers_AccessProfileId",
 0249                table: "AspNetUsers",
 0250                column: "AccessProfileId");
 251
 0252            migrationBuilder.CreateIndex(
 0253                name: "UserNameIndex",
 0254                table: "AspNetUsers",
 0255                column: "NormalizedUserName",
 0256                unique: true);
 0257        }
 258
 259        /// <inheritdoc />
 260        protected override void Down(MigrationBuilder migrationBuilder)
 261        {
 0262            migrationBuilder.DropTable(
 0263                name: "AspNetRoleClaims");
 264
 0265            migrationBuilder.DropTable(
 0266                name: "AspNetUserClaims");
 267
 0268            migrationBuilder.DropTable(
 0269                name: "AspNetUserLogins");
 270
 0271            migrationBuilder.DropTable(
 0272                name: "AspNetUserRoles");
 273
 0274            migrationBuilder.DropTable(
 0275                name: "AspNetUserTokens");
 276
 0277            migrationBuilder.DropTable(
 0278                name: "AspNetRoles");
 279
 0280            migrationBuilder.DropTable(
 0281                name: "AspNetUsers");
 0282        }
 283    }
 284}

/home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Migrations/OzonIdentityOrder/20260908110100_Baseline.Designer.cs

#LineLine coverage
 1// <auto-generated />
 2using System;
 3using Microsoft.EntityFrameworkCore;
 4using Microsoft.EntityFrameworkCore.Infrastructure;
 5using Microsoft.EntityFrameworkCore.Metadata;
 6using Microsoft.EntityFrameworkCore.Migrations;
 7using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 8using OzonRepositories.Context.Identity;
 9
 10#nullable disable
 11
 12namespace OzonRepositories.Migrations.OzonIdentityOrder
 13{
 14    [DbContext(typeof(OzonIdentityOrderContext))]
 15    [Migration("20260908110100_Baseline")]
 16    partial class Baseline
 17    {
 18        /// <inheritdoc />
 19        protected override void BuildTargetModel(ModelBuilder modelBuilder)
 20        {
 21#pragma warning disable 612, 618
 022            modelBuilder
 023                .HasAnnotation("ProductVersion", "8.0.10")
 024                .HasAnnotation("Relational:MaxIdentifierLength", 64);
 25
 026            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
 27
 028            modelBuilder.Entity("AccessProfileDataScopeSet", b =>
 029                {
 030                    b.Property<int>("AccessProfilesId")
 031                        .HasColumnType("int");
 032
 033                    b.Property<int>("DataScopeSetsId")
 034                        .HasColumnType("int");
 035
 036                    b.HasKey("AccessProfilesId", "DataScopeSetsId");
 037
 038                    b.HasIndex("DataScopeSetsId");
 039
 040                    b.ToTable("AccessProfileDataScopeSets", null, t =>
 041                        {
 042                            t.ExcludeFromMigrations();
 043                        });
 044                });
 45
 046            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
 047                {
 048                    b.Property<string>("Id")
 049                        .HasColumnType("varchar(255)");
 050
 051                    b.Property<string>("ConcurrencyStamp")
 052                        .IsConcurrencyToken()
 053                        .HasColumnType("longtext");
 054
 055                    b.Property<string>("Name")
 056                        .HasMaxLength(256)
 057                        .HasColumnType("varchar(256)");
 058
 059                    b.Property<string>("NormalizedName")
 060                        .HasMaxLength(256)
 061                        .HasColumnType("varchar(256)");
 062
 063                    b.HasKey("Id");
 064
 065                    b.HasIndex("NormalizedName")
 066                        .IsUnique()
 067                        .HasDatabaseName("RoleNameIndex");
 068
 069                    b.ToTable("AspNetRoles", (string)null);
 070                });
 71
 072            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
 073                {
 074                    b.Property<int>("Id")
 075                        .ValueGeneratedOnAdd()
 076                        .HasColumnType("int");
 077
 078                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
 079
 080                    b.Property<string>("ClaimType")
 081                        .HasColumnType("longtext");
 082
 083                    b.Property<string>("ClaimValue")
 084                        .HasColumnType("longtext");
 085
 086                    b.Property<string>("RoleId")
 087                        .IsRequired()
 088                        .HasColumnType("varchar(255)");
 089
 090                    b.HasKey("Id");
 091
 092                    b.HasIndex("RoleId");
 093
 094                    b.ToTable("AspNetRoleClaims", (string)null);
 095                });
 96
 097            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
 098                {
 099                    b.Property<int>("Id")
 0100                        .ValueGeneratedOnAdd()
 0101                        .HasColumnType("int");
 0102
 0103                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
 0104
 0105                    b.Property<string>("ClaimType")
 0106                        .HasColumnType("longtext");
 0107
 0108                    b.Property<string>("ClaimValue")
 0109                        .HasColumnType("longtext");
 0110
 0111                    b.Property<string>("UserId")
 0112                        .IsRequired()
 0113                        .HasColumnType("varchar(255)");
 0114
 0115                    b.HasKey("Id");
 0116
 0117                    b.HasIndex("UserId");
 0118
 0119                    b.ToTable("AspNetUserClaims", (string)null);
 0120                });
 121
 0122            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
 0123                {
 0124                    b.Property<string>("LoginProvider")
 0125                        .HasMaxLength(128)
 0126                        .HasColumnType("varchar(128)");
 0127
 0128                    b.Property<string>("ProviderKey")
 0129                        .HasMaxLength(128)
 0130                        .HasColumnType("varchar(128)");
 0131
 0132                    b.Property<string>("ProviderDisplayName")
 0133                        .HasColumnType("longtext");
 0134
 0135                    b.Property<string>("UserId")
 0136                        .IsRequired()
 0137                        .HasColumnType("varchar(255)");
 0138
 0139                    b.HasKey("LoginProvider", "ProviderKey");
 0140
 0141                    b.HasIndex("UserId");
 0142
 0143                    b.ToTable("AspNetUserLogins", (string)null);
 0144                });
 145
 0146            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
 0147                {
 0148                    b.Property<string>("UserId")
 0149                        .HasColumnType("varchar(255)");
 0150
 0151                    b.Property<string>("RoleId")
 0152                        .HasColumnType("varchar(255)");
 0153
 0154                    b.HasKey("UserId", "RoleId");
 0155
 0156                    b.HasIndex("RoleId");
 0157
 0158                    b.ToTable("AspNetUserRoles", (string)null);
 0159                });
 160
 0161            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
 0162                {
 0163                    b.Property<string>("UserId")
 0164                        .HasColumnType("varchar(255)");
 0165
 0166                    b.Property<string>("LoginProvider")
 0167                        .HasMaxLength(128)
 0168                        .HasColumnType("varchar(128)");
 0169
 0170                    b.Property<string>("Name")
 0171                        .HasMaxLength(128)
 0172                        .HasColumnType("varchar(128)");
 0173
 0174                    b.Property<string>("Value")
 0175                        .HasColumnType("longtext");
 0176
 0177                    b.HasKey("UserId", "LoginProvider", "Name");
 0178
 0179                    b.ToTable("AspNetUserTokens", (string)null);
 0180                });
 181
 0182            modelBuilder.Entity("OzonDomains.Models.AccessControl.AccessProfile", b =>
 0183                {
 0184                    b.Property<int>("Id")
 0185                        .ValueGeneratedOnAdd()
 0186                        .HasColumnType("int");
 0187
 0188                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
 0189
 0190                    b.Property<string>("AvailableOrderColumns")
 0191                        .HasColumnType("longtext");
 0192
 0193                    b.Property<string>("Name")
 0194                        .HasColumnType("longtext");
 0195
 0196                    b.HasKey("Id");
 0197
 0198                    b.ToTable("AccessProfiles", null, t =>
 0199                        {
 0200                            t.ExcludeFromMigrations();
 0201                        });
 0202                });
 203
 0204            modelBuilder.Entity("OzonDomains.Models.AccessControl.DataScopeSet", b =>
 0205                {
 0206                    b.Property<int>("Id")
 0207                        .ValueGeneratedOnAdd()
 0208                        .HasColumnType("int");
 0209
 0210                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
 0211
 0212                    b.Property<DateTime>("CreatedAt")
 0213                        .HasColumnType("datetime(6)");
 0214
 0215                    b.Property<string>("Description")
 0216                        .HasMaxLength(500)
 0217                        .HasColumnType("varchar(500)");
 0218
 0219                    b.Property<string>("Name")
 0220                        .IsRequired()
 0221                        .HasMaxLength(200)
 0222                        .HasColumnType("varchar(200)");
 0223
 0224                    b.HasKey("Id");
 0225
 0226                    b.ToTable("DataScopeSets", null, t =>
 0227                        {
 0228                            t.ExcludeFromMigrations();
 0229                        });
 0230                });
 231
 0232            modelBuilder.Entity("OzonDomains.Models.AccessControl.DataScopeSetItem", b =>
 0233                {
 0234                    b.Property<int>("Id")
 0235                        .ValueGeneratedOnAdd()
 0236                        .HasColumnType("int");
 0237
 0238                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
 0239
 0240                    b.Property<int>("DataScopeSetId")
 0241                        .HasColumnType("int");
 0242
 0243                    b.Property<int>("ReferenceId")
 0244                        .HasColumnType("int");
 0245
 0246                    b.Property<int>("ScopeType")
 0247                        .HasColumnType("int");
 0248
 0249                    b.HasKey("Id");
 0250
 0251                    b.HasIndex("DataScopeSetId");
 0252
 0253                    b.ToTable("DataScopeSetItems", null, t =>
 0254                        {
 0255                            t.ExcludeFromMigrations();
 0256                        });
 0257                });
 258
 0259            modelBuilder.Entity("OzonRepositories.Context.Identity.CustomIdentityUser", b =>
 0260                {
 0261                    b.Property<string>("Id")
 0262                        .HasColumnType("varchar(255)");
 0263
 0264                    b.Property<int>("AccessFailedCount")
 0265                        .HasColumnType("int");
 0266
 0267                    b.Property<int?>("AccessProfileId")
 0268                        .HasColumnType("int");
 0269
 0270                    b.Property<DateTime?>("AdminApprovedAtUtc")
 0271                        .HasColumnType("datetime(6)");
 0272
 0273                    b.Property<string>("AdminApprovedBy")
 0274                        .HasColumnType("longtext");
 0275
 0276                    b.Property<string>("ConcurrencyStamp")
 0277                        .IsConcurrencyToken()
 0278                        .HasColumnType("longtext");
 0279
 0280                    b.Property<string>("Discriminator")
 0281                        .IsRequired()
 0282                        .HasMaxLength(21)
 0283                        .HasColumnType("varchar(21)");
 0284
 0285                    b.Property<string>("Email")
 0286                        .HasMaxLength(256)
 0287                        .HasColumnType("varchar(256)");
 0288
 0289                    b.Property<bool>("EmailConfirmed")
 0290                        .HasColumnType("tinyint(1)");
 0291
 0292                    b.Property<string>("GoogleAvatarUrl")
 0293                        .HasColumnType("longtext");
 0294
 0295                    b.Property<string>("GoogleDisplayName")
 0296                        .HasColumnType("longtext");
 0297
 0298                    b.Property<bool>("IsAdminApproved")
 0299                        .HasColumnType("tinyint(1)");
 0300
 0301                    b.Property<bool>("LockoutEnabled")
 0302                        .HasColumnType("tinyint(1)");
 0303
 0304                    b.Property<DateTimeOffset?>("LockoutEnd")
 0305                        .HasColumnType("datetime(6)");
 0306
 0307                    b.Property<string>("NormalizedEmail")
 0308                        .HasMaxLength(256)
 0309                        .HasColumnType("varchar(256)");
 0310
 0311                    b.Property<string>("NormalizedUserName")
 0312                        .HasMaxLength(256)
 0313                        .HasColumnType("varchar(256)");
 0314
 0315                    b.Property<string>("PasswordHash")
 0316                        .HasColumnType("longtext");
 0317
 0318                    b.Property<string>("PhoneNumber")
 0319                        .HasColumnType("longtext");
 0320
 0321                    b.Property<bool>("PhoneNumberConfirmed")
 0322                        .HasColumnType("tinyint(1)");
 0323
 0324                    b.Property<string>("SecurityStamp")
 0325                        .HasColumnType("longtext");
 0326
 0327                    b.Property<bool>("TwoFactorEnabled")
 0328                        .HasColumnType("tinyint(1)");
 0329
 0330                    b.Property<string>("UserName")
 0331                        .HasMaxLength(256)
 0332                        .HasColumnType("varchar(256)");
 0333
 0334                    b.HasKey("Id");
 0335
 0336                    b.HasIndex("AccessProfileId");
 0337
 0338                    b.HasIndex("NormalizedEmail")
 0339                        .HasDatabaseName("EmailIndex");
 0340
 0341                    b.HasIndex("NormalizedUserName")
 0342                        .IsUnique()
 0343                        .HasDatabaseName("UserNameIndex");
 0344
 0345                    b.ToTable("AspNetUsers", (string)null);
 0346
 0347                    b.HasDiscriminator<string>("Discriminator").IsComplete(false).HasValue("CustomIdentityUser");
 0348                });
 349
 0350            modelBuilder.Entity("AccessProfileDataScopeSet", b =>
 0351                {
 0352                    b.HasOne("OzonDomains.Models.AccessControl.AccessProfile", null)
 0353                        .WithMany()
 0354                        .HasForeignKey("AccessProfilesId")
 0355                        .OnDelete(DeleteBehavior.Cascade)
 0356                        .IsRequired();
 0357
 0358                    b.HasOne("OzonDomains.Models.AccessControl.DataScopeSet", null)
 0359                        .WithMany()
 0360                        .HasForeignKey("DataScopeSetsId")
 0361                        .OnDelete(DeleteBehavior.Cascade)
 0362                        .IsRequired();
 0363                });
 364
 0365            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
 0366                {
 0367                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
 0368                        .WithMany()
 0369                        .HasForeignKey("RoleId")
 0370                        .OnDelete(DeleteBehavior.Cascade)
 0371                        .IsRequired();
 0372                });
 373
 0374            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
 0375                {
 0376                    b.HasOne("OzonRepositories.Context.Identity.CustomIdentityUser", null)
 0377                        .WithMany()
 0378                        .HasForeignKey("UserId")
 0379                        .OnDelete(DeleteBehavior.Cascade)
 0380                        .IsRequired();
 0381                });
 382
 0383            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
 0384                {
 0385                    b.HasOne("OzonRepositories.Context.Identity.CustomIdentityUser", null)
 0386                        .WithMany()
 0387                        .HasForeignKey("UserId")
 0388                        .OnDelete(DeleteBehavior.Cascade)
 0389                        .IsRequired();
 0390                });
 391
 0392            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
 0393                {
 0394                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
 0395                        .WithMany()
 0396                        .HasForeignKey("RoleId")
 0397                        .OnDelete(DeleteBehavior.Cascade)
 0398                        .IsRequired();
 0399
 0400                    b.HasOne("OzonRepositories.Context.Identity.CustomIdentityUser", null)
 0401                        .WithMany()
 0402                        .HasForeignKey("UserId")
 0403                        .OnDelete(DeleteBehavior.Cascade)
 0404                        .IsRequired();
 0405                });
 406
 0407            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
 0408                {
 0409                    b.HasOne("OzonRepositories.Context.Identity.CustomIdentityUser", null)
 0410                        .WithMany()
 0411                        .HasForeignKey("UserId")
 0412                        .OnDelete(DeleteBehavior.Cascade)
 0413                        .IsRequired();
 0414                });
 415
 0416            modelBuilder.Entity("OzonDomains.Models.AccessControl.DataScopeSetItem", b =>
 0417                {
 0418                    b.HasOne("OzonDomains.Models.AccessControl.DataScopeSet", "DataScopeSet")
 0419                        .WithMany("Items")
 0420                        .HasForeignKey("DataScopeSetId")
 0421                        .OnDelete(DeleteBehavior.Cascade)
 0422                        .IsRequired()
 0423                        .HasConstraintName("FK_DataScopeSetItems_DataScopeSets");
 0424
 0425                    b.Navigation("DataScopeSet");
 0426                });
 427
 0428            modelBuilder.Entity("OzonRepositories.Context.Identity.CustomIdentityUser", b =>
 0429                {
 0430                    b.HasOne("OzonDomains.Models.AccessControl.AccessProfile", "AccessProfile")
 0431                        .WithMany()
 0432                        .HasForeignKey("AccessProfileId")
 0433                        .OnDelete(DeleteBehavior.SetNull);
 0434
 0435                    b.Navigation("AccessProfile");
 0436                });
 437
 0438            modelBuilder.Entity("OzonDomains.Models.AccessControl.DataScopeSet", b =>
 0439                {
 0440                    b.Navigation("Items");
 0441                });
 442#pragma warning restore 612, 618
 0443        }
 444    }
 445}
Generated by: ReportGenerator 5.5.11.0
10/25/2026 - 07:43:47
GitHub | reportgenerator.io

Methods/Properties

Up(Microsoft.EntityFrameworkCore.Migrations.MigrationBuilder)
Down(Microsoft.EntityFrameworkCore.Migrations.MigrationBuilder)
BuildTargetModel(Microsoft.EntityFrameworkCore.ModelBuilder)