using System;
using System.Collections.Generic;
using System.Text.Json;

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<Divisa> Divisas { 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<Log> Logs { get; set; }

    public virtual DbSet<LogDetalle> LogDetalles { 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)
    {
        if (!optionsBuilder.IsConfigured)
        {
            try
            {
                var jsonContent = File.ReadAllText("settings.json");
                var options = JsonSerializer.Deserialize<Dictionary<string, string>>(jsonContent);
                if (options != null && options.ContainsKey("connectiondb"))
                {
                    optionsBuilder.UseMySQL(options["connectiondb"]);
                }
                else
                {
                    throw new Exception("No se encontró la clave 'connectiondb' en el archivo settings.json");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error al configurar la conexión a la base de datos: {ex.Message}");
                throw;
            }
        }
    }
    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.EmailRecuperacion)
                .HasMaxLength(50)
                .HasColumnName("emailRecuperacion");
            entity.Property(e => e.F2a)
                .HasMaxLength(6)
                .HasColumnName("f2a");
            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.HasIndex(e => e.Iddivisa, "FK_contdiv");

            entity.Property(e => e.Id)
                .HasColumnType("bigint(20)")
                .HasColumnName("id");
            entity.Property(e => e.Cancelado)
                .HasColumnType("bit(1)")
                .HasColumnName("cancelado");
            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.Iddivisa)
                .HasColumnType("int(11)")
                .HasColumnName("iddivisa");
            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.MesesDurationContrato).HasColumnType("int(11)");
            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.IddivisaNavigation).WithMany(p => p.Contratos)
                .HasForeignKey(d => d.Iddivisa)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_contdiv");

            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.HasIndex(e => e.Iddivisa, "FK_defdiv");

            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(100)
                .HasColumnName("descripcion");
            entity.Property(e => e.Idcontrato)
                .HasColumnType("bigint(20)")
                .HasColumnName("idcontrato");
            entity.Property(e => e.Iddivisa)
                .HasColumnType("int(11)")
                .HasColumnName("iddivisa");
            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.IddivisaNavigation).WithMany(p => p.Defectos)
                .HasForeignKey(d => d.Iddivisa)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_defdiv");

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

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

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Signo)
                .HasMaxLength(3)
                .HasColumnName("signo");
        });

        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(30)
                .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.Id).HasName("PRIMARY");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Apellido)
                .HasMaxLength(20)
                .HasColumnName("apellido");
            entity.Property(e => e.Celular)
                .HasMaxLength(40)
                .HasColumnName("celular");
            entity.Property(e => e.Dni)
                .HasColumnType("bigint(20)")
                .HasColumnName("dni");
            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.Idgarantes)
                .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("Idgarante")
                        .OnDelete(DeleteBehavior.Restrict)
                        .HasConstraintName("FK_CONGAR_GAR"),
                    j =>
                    {
                        j.HasKey("Idgarante", "Idcontrato").HasName("PRIMARY");
                        j.ToTable("contrato_garantes");
                        j.HasIndex(new[] { "Idcontrato" }, "FK_CONGAR_CON");
                        j.IndexerProperty<int>("Idgarante")
                            .HasColumnType("int(11)")
                            .HasColumnName("idgarante");
                        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.Habilitado)
                .IsRequired()
                .HasDefaultValueSql("'1'")
                .HasColumnName("habilitado");
            entity.Property(e => e.Nombre)
                .HasMaxLength(12)
                .HasColumnName("nombre");

            entity.HasMany(d => d.IdGrupoHijos).WithMany(p => p.IdGrupoPadres)
                .UsingEntity<Dictionary<string, object>>(
                    "GrupoSubgrupo",
                    r => r.HasOne<Grupo>().WithMany()
                        .HasForeignKey("IdGrupoHijo")
                        .HasConstraintName("Grupo_Subgrupo_ibfk_2"),
                    l => l.HasOne<Grupo>().WithMany()
                        .HasForeignKey("IdGrupoPadre")
                        .HasConstraintName("Grupo_Subgrupo_ibfk_1"),
                    j =>
                    {
                        j.HasKey("IdGrupoPadre", "IdGrupoHijo").HasName("PRIMARY");
                        j.ToTable("Grupo_Subgrupo");
                        j.HasIndex(new[] { "IdGrupoHijo" }, "IdGrupoHijo");
                        j.IndexerProperty<int>("IdGrupoPadre").HasColumnType("int(11)");
                        j.IndexerProperty<int>("IdGrupoHijo").HasColumnType("int(11)");
                    });

            entity.HasMany(d => d.IdGrupoPadres).WithMany(p => p.IdGrupoHijos)
                .UsingEntity<Dictionary<string, object>>(
                    "GrupoSubgrupo",
                    r => r.HasOne<Grupo>().WithMany()
                        .HasForeignKey("IdGrupoPadre")
                        .HasConstraintName("Grupo_Subgrupo_ibfk_1"),
                    l => l.HasOne<Grupo>().WithMany()
                        .HasForeignKey("IdGrupoHijo")
                        .HasConstraintName("Grupo_Subgrupo_ibfk_2"),
                    j =>
                    {
                        j.HasKey("IdGrupoPadre", "IdGrupoHijo").HasName("PRIMARY");
                        j.ToTable("Grupo_Subgrupo");
                        j.HasIndex(new[] { "IdGrupoHijo" }, "IdGrupoHijo");
                        j.IndexerProperty<int>("IdGrupoPadre").HasColumnType("int(11)");
                        j.IndexerProperty<int>("IdGrupoHijo").HasColumnType("int(11)");
                    });
        });

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

            entity.ToTable("Log");

            entity.HasIndex(e => e.Dniusuario, "fk_log_clientes");

            entity.Property(e => e.Fecha)
                .HasColumnType("datetime")
                .HasColumnName("fecha");
            entity.Property(e => e.Dniusuario)
                .HasColumnType("bigint(20)")
                .HasColumnName("dniusuario");
            entity.Property(e => e.Accion)
                .HasMaxLength(255)
                .HasColumnName("accion");

            entity.HasOne(d => d.DniusuarioNavigation).WithMany(p => p.Logs)
                .HasForeignKey(d => d.Dniusuario)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("fk_log_clientes");
        });

        modelBuilder.Entity<LogDetalle>(entity =>
        {
            entity.HasKey(e => new { e.Id, e.Fecha, e.Dniusuario, e.NombreTabla, e.Columna }).HasName("PRIMARY");

            entity.ToTable("LogDetalle");

            entity.HasIndex(e => new { e.Fecha, e.Dniusuario }, "LogDetalle_ibfk_1");

            entity.Property(e => e.Id)
                .HasColumnType("int(11)")
                .HasColumnName("id");
            entity.Property(e => e.Fecha)
                .HasColumnType("datetime")
                .HasColumnName("fecha");
            entity.Property(e => e.Dniusuario)
                .HasColumnType("bigint(20)")
                .HasColumnName("dniusuario");
            entity.Property(e => e.NombreTabla).HasColumnName("nombreTabla");
            entity.Property(e => e.Columna).HasColumnName("columna");
            entity.Property(e => e.ValorAnterior)
                .HasColumnType("text")
                .HasColumnName("valorAnterior");
            entity.Property(e => e.ValorNuevo)
                .HasColumnType("text")
                .HasColumnName("valorNuevo");

            entity.HasOne(d => d.Log).WithMany(p => p.LogDetalles)
                .HasForeignKey(d => new { d.Fecha, d.Dniusuario })
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("LogDetalle_ibfk_1");
        });

        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(30)
                .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.HasIndex(e => e.Iddivisa, "FK_propdiv");

            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.Iddivisa)
                .HasColumnType("int(11)")
                .HasColumnName("iddivisa");
            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.IddivisaNavigation).WithMany(p => p.Propiedades)
                .HasForeignKey(d => d.Iddivisa)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_propdiv");

            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.HasIndex(e => e.Iddivisa, "FK_ventdiv");

            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.Iddivisa)
                .HasColumnType("int(11)")
                .HasColumnName("iddivisa");
            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.Property(e => e.UrlRecibo)
                .HasColumnType("text")
                .HasColumnName("urlRecibo");

            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.IddivisaNavigation).WithMany(p => p.Venta)
                .HasForeignKey(d => d.Iddivisa)
                .OnDelete(DeleteBehavior.Restrict)
                .HasConstraintName("FK_ventdiv");

            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);
}