using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using Pomelo.EntityFrameworkCore.MySql.Scaffolding.Internal;

namespace shoe_store.Models;

public partial class Ispr2521TimofeevKoShoestoreContext : DbContext
{
    public Ispr2521TimofeevKoShoestoreContext()
    {
    }

    public Ispr2521TimofeevKoShoestoreContext(DbContextOptions<Ispr2521TimofeevKoShoestoreContext> options)
        : base(options)
    {
    }

    public virtual DbSet<Category> Categories { get; set; }

    public virtual DbSet<Manufacturer> Manufacturers { get; set; }

    public virtual DbSet<Order> Orders { get; set; }

    public virtual DbSet<OrderItem> OrderItems { get; set; }

    public virtual DbSet<OrderStatus> OrderStatuses { get; set; }

    public virtual DbSet<PickupPoint> PickupPoints { get; set; }

    public virtual DbSet<Product> Products { get; set; }

    public virtual DbSet<Role> Roles { get; set; }

    public virtual DbSet<Supplier> Suppliers { get; set; }

    public virtual DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see https://go.microsoft.com/fwlink/?LinkId=723263.
        => optionsBuilder.UseMySql("server=cfif31.ru;username=ISPr25-21_TimofeevKO;password=ISPr25-21_TimofeevKO;database=ISPr25-21_TimofeevKO_shoestore", Microsoft.EntityFrameworkCore.ServerVersion.Parse("8.0.45-mysql"));

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder
            .UseCollation("utf8mb4_0900_ai_ci")
            .HasCharSet("utf8mb4");

        modelBuilder.Entity<Category>(entity =>
        {
            entity.HasKey(e => e.IdCategory).HasName("PRIMARY");

            entity.ToTable("Category");

            entity.Property(e => e.IdCategory).HasColumnName("id_Category");
            entity.Property(e => e.CategoryName)
                .HasMaxLength(45)
                .HasColumnName("Category_name");
        });

        modelBuilder.Entity<Manufacturer>(entity =>
        {
            entity.HasKey(e => e.IdManufacturer).HasName("PRIMARY");

            entity.ToTable("Manufacturer");

            entity.Property(e => e.IdManufacturer).HasColumnName("id_Manufacturer");
            entity.Property(e => e.ManufacturerName)
                .HasMaxLength(45)
                .HasColumnName("Manufacturer_name");
        });

        modelBuilder.Entity<Order>(entity =>
        {
            entity.HasKey(e => e.IdOrders).HasName("PRIMARY");

            entity.HasIndex(e => e.PickupPointId, "from order to pickup_idx");

            entity.HasIndex(e => e.OrderstatusId, "from order to status_idx");

            entity.HasIndex(e => e.UserInitialsId, "from order to user_idx");

            entity.Property(e => e.IdOrders).HasColumnName("id_Orders");
            entity.Property(e => e.Code).HasColumnName("code");
            entity.Property(e => e.DeliveryDate).HasColumnName("delivery_date");
            entity.Property(e => e.OrderDate).HasColumnName("order_date");
            entity.Property(e => e.OrderstatusId).HasColumnName("orderstatus_id");
            entity.Property(e => e.PickupPointId).HasColumnName("pickup_point_id");
            entity.Property(e => e.UserInitialsId).HasColumnName("user_initials_id");

            entity.HasOne(d => d.Orderstatus).WithMany(p => p.Orders)
                .HasForeignKey(d => d.OrderstatusId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from order to status");

            entity.HasOne(d => d.PickupPoint).WithMany(p => p.Orders)
                .HasForeignKey(d => d.PickupPointId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from order to pickup");

            entity.HasOne(d => d.UserInitials).WithMany(p => p.Orders)
                .HasForeignKey(d => d.UserInitialsId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from order to user");
        });

        modelBuilder.Entity<OrderItem>(entity =>
        {
            entity.HasKey(e => e.IdOrderItems).HasName("PRIMARY");

            entity.HasIndex(e => e.OrderId, "from items to order_idx");

            entity.HasIndex(e => e.ProductArticle, "from items to product_idx");

            entity.Property(e => e.IdOrderItems).HasColumnName("id_OrderItems");
            entity.Property(e => e.OrderId).HasColumnName("order_id");
            entity.Property(e => e.ProductArticle)
                .HasMaxLength(20)
                .HasColumnName("product_article");
            entity.Property(e => e.Quantity).HasColumnName("quantity");

            entity.HasOne(d => d.Order).WithMany(p => p.OrderItems)
                .HasForeignKey(d => d.OrderId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from items to order");

            entity.HasOne(d => d.ProductArticleNavigation).WithMany(p => p.OrderItems)
                .HasForeignKey(d => d.ProductArticle)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from items to product");
        });

        modelBuilder.Entity<OrderStatus>(entity =>
        {
            entity.HasKey(e => e.IdOrderStatus).HasName("PRIMARY");

            entity.ToTable("OrderStatus");

            entity.Property(e => e.IdOrderStatus).HasColumnName("id_OrderStatus");
            entity.Property(e => e.StatusName)
                .HasMaxLength(75)
                .HasColumnName("status_name");
        });

        modelBuilder.Entity<PickupPoint>(entity =>
        {
            entity.HasKey(e => e.IdpickupPoints).HasName("PRIMARY");

            entity.ToTable("pickup_points");

            entity.Property(e => e.IdpickupPoints).HasColumnName("idpickup_points");
            entity.Property(e => e.City)
                .HasMaxLength(75)
                .HasColumnName("city");
            entity.Property(e => e.HouseNumber).HasColumnName("house_number");
            entity.Property(e => e.Index).HasColumnName("index");
            entity.Property(e => e.Street)
                .HasMaxLength(100)
                .HasColumnName("street");
        });

        modelBuilder.Entity<Product>(entity =>
        {
            entity.HasKey(e => e.ArticleProduct).HasName("PRIMARY");

            entity.ToTable("products");

            entity.HasIndex(e => e.CategoryId, "from prod to category_idx");

            entity.HasIndex(e => e.ManufacturerId, "from prod to manufacturer_idx");

            entity.HasIndex(e => e.SupplierId, "from prod to suppleir_idx");

            entity.Property(e => e.ArticleProduct)
                .HasMaxLength(20)
                .HasColumnName("article_product");
            entity.Property(e => e.CategoryId).HasColumnName("category_id");
            entity.Property(e => e.Description)
                .HasColumnType("text")
                .HasColumnName("description");
            entity.Property(e => e.ManufacturerId).HasColumnName("manufacturer_id");
            entity.Property(e => e.Photo)
                .HasColumnType("mediumblob")
                .HasColumnName("photo");
            entity.Property(e => e.Price)
                .HasPrecision(10, 2)
                .HasColumnName("price");
            entity.Property(e => e.ProductName)
                .HasMaxLength(100)
                .HasColumnName("product_name");
            entity.Property(e => e.QuantityInStock).HasColumnName("quantity_in_stock");
            entity.Property(e => e.SalePercent).HasColumnName("sale_percent");
            entity.Property(e => e.SupplierId).HasColumnName("supplier_id");
            entity.Property(e => e.UnitType)
                .HasMaxLength(45)
                .HasColumnName("unit_type");

            entity.HasOne(d => d.Category).WithMany(p => p.Products)
                .HasForeignKey(d => d.CategoryId)
                .HasConstraintName("from prod to category");

            entity.HasOne(d => d.Manufacturer).WithMany(p => p.Products)
                .HasForeignKey(d => d.ManufacturerId)
                .HasConstraintName("from prod to manufacturer");

            entity.HasOne(d => d.Supplier).WithMany(p => p.Products)
                .HasForeignKey(d => d.SupplierId)
                .HasConstraintName("from prod to suppleir");
        });

        modelBuilder.Entity<Role>(entity =>
        {
            entity.HasKey(e => e.IdRole).HasName("PRIMARY");

            entity.ToTable("Role");

            entity.Property(e => e.IdRole).HasColumnName("idRole");
            entity.Property(e => e.RoleName)
                .HasMaxLength(75)
                .HasColumnName("Role_name");
        });

        modelBuilder.Entity<Supplier>(entity =>
        {
            entity.HasKey(e => e.IdSupplier).HasName("PRIMARY");

            entity.ToTable("Supplier");

            entity.Property(e => e.IdSupplier).HasColumnName("id_Supplier");
            entity.Property(e => e.SupplierName)
                .HasMaxLength(75)
                .HasColumnName("supplier_name");
        });

        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(e => e.IdUsers).HasName("PRIMARY");

            entity.ToTable("users");

            entity.HasIndex(e => e.RoleId, "from users to role_idx");

            entity.Property(e => e.IdUsers).HasColumnName("id_users");
            entity.Property(e => e.Login)
                .HasMaxLength(45)
                .HasColumnName("login");
            entity.Property(e => e.Name).HasMaxLength(45);
            entity.Property(e => e.Password)
                .HasMaxLength(45)
                .HasColumnName("password");
            entity.Property(e => e.Patronymic).HasMaxLength(45);
            entity.Property(e => e.RoleId).HasColumnName("RoleID");
            entity.Property(e => e.Surname).HasMaxLength(45);

            entity.HasOne(d => d.Role).WithMany(p => p.Users)
                .HasForeignKey(d => d.RoleId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("from users to role");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}