using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace Entidades;

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

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

    public virtual DbSet<Canon> Canons { get; set; }

    public virtual DbSet<Cliente> Clientes { get; set; }

    public virtual DbSet<Contrato> Contratos { get; set; }

    public virtual DbSet<Defecto> Defectos { get; set; }

    public virtual DbSet<EstadoPropiedad> EstadoPropiedads { get; set; }

    public virtual DbSet<Estadodefecto> Estadodefectos { get; set; }

    public virtual DbSet<Estadoventa> Estadoventas { get; set; }

    public virtual DbSet<Garante> Garantes { get; set; }

    public virtual DbSet<Grupo> Grupos { get; set; }

    public virtual DbSet<Notificacione> Notificaciones { get; set; }

    public virtual DbSet<Permiso> Permisos { get; set; }

    public virtual DbSet<Propiedade> Propiedades { get; set; }

    public virtual DbSet<Recibo> Recibos { get; set; }

    public virtual DbSet<Servicio> Servicios { get; set; }

    public virtual DbSet<TipoPropiedad> TipoPropiedads { get; set; }

    public virtual DbSet<Venta> Ventas { 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=fedesrv.ddns.net;Port=30006;Database=AlquilaFacil;Uid=AlquilaFacil;Pwd=.n@9c2ve*0,b1ETv].Kipa/~pR~V;Connection Timeout=5;SslMode=none");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Canon>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PRIMARY");

            entity.ToTable("Canon");

            entity.HasIndex(e => e.Idrecibo, "FK_CAN_REC");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Fecha)
                .HasColumnType("date")
                .HasColumnName("fecha");
            entity.Property(e => e.Idrecibo)
                .HasColumnType("bigint(20)")
                .HasColumnName("idrecibo");
            entity.Property(e => e.Monto)
                .HasPrecision(12)
                .HasColumnName("monto");
            entity.Property(e => e.Pagado)
                .HasColumnType("bit(1)")
                .HasColumnName("pagado");

            entity.HasOne(d => d.IdreciboNavigation).WithMany(p => p.Canons)
                .HasForeignKey(d => d.Idrecibo)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_CAN_REC");
        });

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

            entity.Property(e => e.Dni)
                .HasColumnType("bigint(20)")
                .HasColumnName("dni");
            entity.Property(e => e.Apellido)
                .HasMaxLength(20)
                .HasColumnName("apellido");
            entity.Property(e => e.Celular)
                .HasMaxLength(40)
                .HasColumnName("celular");
            entity.Property(e => e.Contraseña)
                .HasMaxLength(128)
                .HasColumnName("contraseña");
            entity.Property(e => e.Domicilio)
                .HasMaxLength(40)
                .HasColumnName("domicilio");
            entity.Property(e => e.Email)
                .HasMaxLength(50)
                .HasColumnName("email");
            entity.Property(e => e.Habilitado)
                .HasDefaultValueSql("b'1'")
                .HasColumnType("bit(1)")
                .HasColumnName("habilitado");
            entity.Property(e => e.Nombre)
                .HasMaxLength(20)
                .HasColumnName("nombre");
            entity.Property(e => e.Token)
                .HasColumnType("text")
                .HasColumnName("token");

            entity.HasMany(d => d.Idgrupos).WithMany(p => p.Idclientes)
                .UsingEntity<Dictionary<string, object>>(
                    "ClienteGrupo",
                    r => r.HasOne<Grupo>().WithMany()
                        .HasForeignKey("Idgrupo")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_GRU"),
                    l => l.HasOne<Cliente>().WithMany()
                        .HasForeignKey("Idcliente")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CLII"),
                    j =>
                    {
                        j.HasKey("Idcliente", "Idgrupo").HasName("PRIMARY");
                        j.ToTable("cliente_Grupos");
                        j.HasIndex(new[] { "Idgrupo" }, "FK_GRU");
                        j.IndexerProperty<long>("Idcliente")
                            .HasColumnType("bigint(20)")
                            .HasColumnName("idcliente");
                        j.IndexerProperty<int>("Idgrupo")
                            .HasColumnType("int(11)")
                            .HasColumnName("idgrupo");
                    });
        });

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

            entity.HasIndex(e => e.Dniinquilino, "FK_CON_INQ");

            entity.HasIndex(e => e.Idpropiedad, "FK_CON_PROP");

            entity.HasIndex(e => e.Dnipropietario, "FK_CON_PROPI");

            entity.HasIndex(e => e.Idventa, "FK_CON_VEN");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Cantgarantemin)
                .HasColumnType("int(11)")
                .HasColumnName("cantgarantemin");
            entity.Property(e => e.Dniinquilino)
                .HasColumnType("bigint(20)")
                .HasColumnName("dniinquilino");
            entity.Property(e => e.Dnipropietario)
                .HasColumnType("bigint(20)")
                .HasColumnName("dnipropietario");
            entity.Property(e => e.Fechainicio)
                .HasColumnType("date")
                .HasColumnName("fechainicio");
            entity.Property(e => e.Habilitado)
                .HasColumnType("bit(1)")
                .HasColumnName("habilitado");
            entity.Property(e => e.Idpropiedad)
                .HasColumnType("int(11)")
                .HasColumnName("idpropiedad");
            entity.Property(e => e.Idventa)
                .HasColumnType("bigint(20)")
                .HasColumnName("idventa");
            entity.Property(e => e.Indiceactualizacion)
                .HasPrecision(8)
                .HasColumnName("indiceactualizacion");
            entity.Property(e => e.MesesHastaAumento).HasColumnType("int(11)");
            entity.Property(e => e.Monto)
                .HasPrecision(12)
                .HasColumnName("monto");
            entity.Property(e => e.Tieneopcionventa)
                .HasColumnType("bit(1)")
                .HasColumnName("tieneopcionventa");
            entity.Property(e => e.UrlContrato)
                .HasMaxLength(100)
                .HasColumnName("urlContrato");

            entity.HasOne(d => d.DniinquilinoNavigation).WithMany(p => p.ContratoDniinquilinoNavigations)
                .HasForeignKey(d => d.Dniinquilino)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_CON_INQ");

            entity.HasOne(d => d.DnipropietarioNavigation).WithMany(p => p.ContratoDnipropietarioNavigations)
                .HasForeignKey(d => d.Dnipropietario)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_CON_PROPI");

            entity.HasOne(d => d.IdpropiedadNavigation).WithMany(p => p.Contratos)
                .HasForeignKey(d => d.Idpropiedad)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_CON_PROP");

            entity.HasOne(d => d.IdventaNavigation).WithMany(p => p.Contratos)
                .HasForeignKey(d => d.Idventa)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_CON_VEN");

            entity.HasMany(d => d.Idcanons).WithMany(p => p.Idcontratos)
                .UsingEntity<Dictionary<string, object>>(
                    "ContratoCanon",
                    r => r.HasOne<Canon>().WithMany()
                        .HasForeignKey("Idcanon")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CONCAN_CAN"),
                    l => l.HasOne<Contrato>().WithMany()
                        .HasForeignKey("Idcontrato")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CONCAN_CON"),
                    j =>
                    {
                        j.HasKey("Idcontrato", "Idcanon").HasName("PRIMARY");
                        j.ToTable("contrato_canon");
                        j.HasIndex(new[] { "Idcanon" }, "FK_CONCAN_CAN");
                        j.IndexerProperty<long>("Idcontrato")
                            .HasColumnType("bigint(20)")
                            .HasColumnName("idcontrato");
                        j.IndexerProperty<long>("Idcanon")
                            .HasColumnType("bigint(20)")
                            .HasColumnName("idcanon");
                    });
        });

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

            entity.ToTable("Defecto");

            entity.HasIndex(e => e.Idcontrato, "FK_DEF_CON");

            entity.HasIndex(e => e.Idestado, "FK_DEF_EST");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Costo)
                .HasPrecision(12)
                .HasColumnName("costo");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(40)
                .HasColumnName("descripcion");
            entity.Property(e => e.Idcontrato)
                .HasColumnType("bigint(20)")
                .HasColumnName("idcontrato");
            entity.Property(e => e.Idestado)
                .HasColumnType("int(11)")
                .HasColumnName("idestado");
            entity.Property(e => e.Pagainquilino)
                .HasColumnType("bit(1)")
                .HasColumnName("pagainquilino");

            entity.HasOne(d => d.IdcontratoNavigation).WithMany(p => p.Defectos)
                .HasForeignKey(d => d.Idcontrato)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_DEF_CON");

            entity.HasOne(d => d.IdestadoNavigation).WithMany(p => p.Defectos)
                .HasForeignKey(d => d.Idestado)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_DEF_EST");
        });

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

            entity.ToTable("EstadoPropiedad");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(11)
                .HasColumnName("descripcion");
        });

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

            entity.ToTable("Estadodefecto");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descipcion)
                .HasMaxLength(20)
                .HasColumnName("descipcion");
        });

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

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(15)
                .HasColumnName("descripcion");
        });

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

            entity.Property(e => e.Dni)
                .HasColumnType("bigint(20)")
                .HasColumnName("dni");
            entity.Property(e => e.Apellido)
                .HasMaxLength(20)
                .HasColumnName("apellido");
            entity.Property(e => e.Celular)
                .HasMaxLength(40)
                .HasColumnName("celular");
            entity.Property(e => e.Domicilio)
                .HasMaxLength(40)
                .HasColumnName("domicilio");
            entity.Property(e => e.Domiciliolaboral)
                .HasMaxLength(40)
                .HasColumnName("domiciliolaboral");
            entity.Property(e => e.Nombre)
                .HasMaxLength(20)
                .HasColumnName("nombre");

            entity.HasMany(d => d.Idcontratos).WithMany(p => p.Dnigarantes)
                .UsingEntity<Dictionary<string, object>>(
                    "ContratoGarante",
                    r => r.HasOne<Contrato>().WithMany()
                        .HasForeignKey("Idcontrato")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CONGAR_CON"),
                    l => l.HasOne<Garante>().WithMany()
                        .HasForeignKey("Dnigarante")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CONGAR_GAR"),
                    j =>
                    {
                        j.HasKey("Dnigarante", "Idcontrato").HasName("PRIMARY");
                        j.ToTable("contrato_garantes");
                        j.HasIndex(new[] { "Idcontrato" }, "FK_CONGAR_CON");
                        j.IndexerProperty<long>("Dnigarante")
                            .HasColumnType("bigint(20)")
                            .HasColumnName("dnigarante");
                        j.IndexerProperty<long>("Idcontrato")
                            .HasColumnType("bigint(20)")
                            .HasColumnName("idcontrato");
                    });
        });

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

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Nombre)
                .HasMaxLength(12)
                .HasColumnName("nombre");
        });

        modelBuilder.Entity<Notificacione>(entity =>
        {
            entity.HasKey(e => new { e.Dnicliente, e.Fecha }).HasName("PRIMARY");

            entity.HasIndex(e => e.Idpropiedad, "FK_NOTPROP");

            entity.HasIndex(e => e.Dniremitente, "FK_NOTREM");

            entity.Property(e => e.Dnicliente)
                .HasColumnType("bigint(20)")
                .HasColumnName("dnicliente");
            entity.Property(e => e.Fecha)
                .HasColumnType("datetime")
                .HasColumnName("fecha");
            entity.Property(e => e.Accion)
                .HasMaxLength(15)
                .HasColumnName("accion");
            entity.Property(e => e.Dniremitente)
                .HasColumnType("bigint(20)")
                .HasColumnName("dniremitente");
            entity.Property(e => e.Idpropiedad)
                .HasColumnType("int(11)")
                .HasColumnName("idpropiedad");
            entity.Property(e => e.Leido).HasColumnName("leido");
            entity.Property(e => e.Mensaje)
                .HasMaxLength(255)
                .HasColumnName("mensaje");

            entity.HasOne(d => d.DniclienteNavigation).WithMany(p => p.NotificacioneDniclienteNavigations)
                .HasForeignKey(d => d.Dnicliente)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_NOTCLI");

            entity.HasOne(d => d.DniremitenteNavigation).WithMany(p => p.NotificacioneDniremitenteNavigations)
                .HasForeignKey(d => d.Dniremitente)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_NOTREM");

            entity.HasOne(d => d.IdpropiedadNavigation).WithMany(p => p.Notificaciones)
                .HasForeignKey(d => d.Idpropiedad)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_NOTPROP");
        });

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

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(25)
                .HasColumnName("descripcion");

            entity.HasMany(d => d.Idgrupos).WithMany(p => p.Idpermisos)
                .UsingEntity<Dictionary<string, object>>(
                    "GrupoPermiso",
                    r => r.HasOne<Grupo>().WithMany()
                        .HasForeignKey("Idgrupo")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_GRU2"),
                    l => l.HasOne<Permiso>().WithMany()
                        .HasForeignKey("Idpermiso")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_PER2"),
                    j =>
                    {
                        j.HasKey("Idpermiso", "Idgrupo").HasName("PRIMARY");
                        j.ToTable("grupo_Permisos");
                        j.HasIndex(new[] { "Idgrupo" }, "FK_GRU2");
                        j.IndexerProperty<int>("Idpermiso")
                            .HasColumnType("int(11)")
                            .HasColumnName("idpermiso");
                        j.IndexerProperty<int>("Idgrupo")
                            .HasColumnType("int(11)")
                            .HasColumnName("idgrupo");
                    });
        });

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

            entity.HasIndex(e => e.Idestado, "FK_PROP_EST");

            entity.HasIndex(e => e.Dnipropietario, "FK_PROP_PROPI");

            entity.HasIndex(e => e.Idtipropiedad, "FK_PROP_TIPO");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Canthabitaciones)
                .HasColumnType("int(11)")
                .HasColumnName("canthabitaciones");
            entity.Property(e => e.Dnipropietario)
                .HasColumnType("bigint(20)")
                .HasColumnName("dnipropietario");
            entity.Property(e => e.Idestado)
                .HasColumnType("int(11)")
                .HasColumnName("idestado");
            entity.Property(e => e.Idtipropiedad)
                .HasColumnType("int(11)")
                .HasColumnName("idtipropiedad");
            entity.Property(e => e.Letra)
                .HasMaxLength(1)
                .IsFixedLength()
                .HasColumnName("letra");
            entity.Property(e => e.Monto)
                .HasPrecision(10)
                .HasColumnName("monto");
            entity.Property(e => e.Piso)
                .HasColumnType("int(11)")
                .HasColumnName("piso");
            entity.Property(e => e.Ubicacion)
                .HasMaxLength(40)
                .HasColumnName("ubicacion");

            entity.HasOne(d => d.DnipropietarioNavigation).WithMany(p => p.Propiedades)
                .HasForeignKey(d => d.Dnipropietario)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_PROP_PROPI");

            entity.HasOne(d => d.IdestadoNavigation).WithMany(p => p.Propiedades)
                .HasForeignKey(d => d.Idestado)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_PROP_EST");

            entity.HasOne(d => d.IdtipropiedadNavigation).WithMany(p => p.Propiedades)
                .HasForeignKey(d => d.Idtipropiedad)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_PROP_TIPO");
        });

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

            entity.ToTable("Recibo");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Fecha)
                .HasColumnType("date")
                .HasColumnName("fecha");
            entity.Property(e => e.Monto)
                .HasPrecision(12)
                .HasColumnName("monto");
        });

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

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(20)
                .HasColumnName("descripcion");

            entity.HasMany(d => d.IdPropiedads).WithMany(p => p.IdServicios)
                .UsingEntity<Dictionary<string, object>>(
                    "ServicioPropiedad",
                    r => r.HasOne<Propiedade>().WithMany()
                        .HasForeignKey("IdPropiedad")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("Servicio_Propiedad_ibfk_2"),
                    l => l.HasOne<Servicio>().WithMany()
                        .HasForeignKey("IdServicio")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("Servicio_Propiedad_ibfk_1"),
                    j =>
                    {
                        j.HasKey("IdServicio", "IdPropiedad").HasName("PRIMARY");
                        j.ToTable("Servicio_Propiedad");
                        j.HasIndex(new[] { "IdPropiedad" }, "idPropiedad");
                        j.IndexerProperty<int>("IdServicio")
                            .HasColumnType("int(11)")
                            .HasColumnName("idServicio");
                        j.IndexerProperty<int>("IdPropiedad")
                            .HasColumnType("int(11)")
                            .HasColumnName("idPropiedad");
                    });
        });

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

            entity.ToTable("TipoPropiedad");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(20)
                .HasColumnName("descripcion");
        });

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

            entity.HasIndex(e => e.Idestado, "FK_VEN_EST");

            entity.HasIndex(e => e.IdVendedor, "FK_VEN_PROL");

            entity.HasIndex(e => e.IdComprador, "FK_VEN_PRON");

            entity.HasIndex(e => e.Idpropiedad, "FK_VEN_PROP");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Fechafinal)
                .HasColumnType("date")
                .HasColumnName("fechafinal");
            entity.Property(e => e.Fechainicio)
                .HasColumnType("date")
                .HasColumnName("fechainicio");
            entity.Property(e => e.IdComprador)
                .HasColumnType("bigint(20)")
                .HasColumnName("idComprador");
            entity.Property(e => e.IdVendedor)
                .HasColumnType("bigint(20)")
                .HasColumnName("idVendedor");
            entity.Property(e => e.Idestado)
                .HasColumnType("int(11)")
                .HasColumnName("idestado");
            entity.Property(e => e.Idpropiedad)
                .HasColumnType("int(11)")
                .HasColumnName("idpropiedad");
            entity.Property(e => e.Monto)
                .HasPrecision(12)
                .HasColumnName("monto");

            entity.HasOne(d => d.IdCompradorNavigation).WithMany(p => p.VentaIdCompradorNavigations)
                .HasForeignKey(d => d.IdComprador)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_VEN_PRON");

            entity.HasOne(d => d.IdVendedorNavigation).WithMany(p => p.VentaIdVendedorNavigations)
                .HasForeignKey(d => d.IdVendedor)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_VEN_PROL");

            entity.HasOne(d => d.IdestadoNavigation).WithMany(p => p.Venta)
                .HasForeignKey(d => d.Idestado)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_VEN_EST");

            entity.HasOne(d => d.IdpropiedadNavigation).WithMany(p => p.Venta)
                .HasForeignKey(d => d.Idpropiedad)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_VEN_PROP");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}