using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using GPW.Data.DBModels;
using NLog.Fluent;
using NLog;
using Microsoft.Extensions.Configuration;

#nullable disable

namespace GPW.Data
{
    public partial class GPWContext : DbContext
    {
        #region Private Fields

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        private IConfiguration _configuration;

        #endregion Private Fields

        #region Public Constructors

        public GPWContext()
        {
        }

        public GPWContext(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        public GPWContext(DbContextOptions<GPWContext> options) : base(options)
        {
            try
            {
                // se non ci fosse... crea o migra!
                Database.Migrate();
            }
            catch (Exception exc)
            {
                Log.Error(exc, "Exception during context initialization 02");
            }
        }

        #endregion Public Constructors

#if false
        public virtual DbSet<AnagClassiOrarie> AnagClassiOraries { get; set; }

        public virtual DbSet<AnagClienti> AnagClientis { get; set; }

        public virtual DbSet<AnagDevice> AnagDevices { get; set; }

        public virtual DbSet<AnagFasi> AnagFasis { get; set; }

        public virtual DbSet<AnagGiust> AnagGiusts { get; set; }

        public virtual DbSet<AnagGruppi> AnagGruppis { get; set; }

        public virtual DbSet<AnagKeyValue> AnagKeyValues { get; set; }

        public virtual DbSet<AnagOrari> AnagOraris { get; set; }

        public virtual DbSet<AnagProgetti> AnagProgettis { get; set; }

        public virtual DbSet<AnagraficaEventi> AnagraficaEventis { get; set; }

        public virtual DbSet<AnagRuoli> AnagRuolis { get; set; }

        public virtual DbSet<AnagTipoCheck> AnagTipoChecks { get; set; }

        public virtual DbSet<CalendFesteFerie> CalendFesteFeries { get; set; }

        public virtual DbSet<Config> Configs { get; set; }

        public virtual DbSet<Contatori> Contatoris { get; set; }

        public virtual DbSet<ControlloDefrag> ControlloDefrags { get; set; }

        public virtual DbSet<Dipendenti2Ruoli> Dipendenti2Ruolis { get; set; }

        public virtual DbSet<ElencoReport> ElencoReports { get; set; }

        public virtual DbSet<Funzioni> Funzionis { get; set; }

        public virtual DbSet<Giustificativi> Giustificativis { get; set; }

        public virtual DbSet<ImportEgaltech> ImportEgalteches { get; set; }

        public virtual DbSet<ImportEgaltechFase> ImportEgaltechFases { get; set; }

        public virtual DbSet<ImportEgaltechNew> ImportEgaltechNews { get; set; }

        public virtual DbSet<ListValue> ListValues { get; set; }

        public virtual DbSet<LogAttivitum> LogAttivita { get; set; }

        public virtual DbSet<LogUpdateDb> LogUpdateDbs { get; set; }

        public virtual DbSet<OreMensiliExport> OreMensiliExports { get; set; }

        public virtual DbSet<PeriodiLav> PeriodiLavs { get; set; }

        public virtual DbSet<Permessi2Funzione> Permessi2Funziones { get; set; }

        public virtual DbSet<Permessi> Permessis { get; set; }

        public virtual DbSet<RegAttivitum> RegAttivita { get; set; }

        public virtual DbSet<RegAttivitaEgal> RegAttivitaEgals { get; set; }

        public virtual DbSet<RegAttivitaExpl> RegAttivitaExpls { get; set; }

        public virtual DbSet<RegistroEventi> RegistroEventis { get; set; }

        public virtual DbSet<RilievoTemp> RilievoTemps { get; set; }

        public virtual DbSet<Sottoscrizioni> Sottoscrizionis { get; set; }

        public virtual DbSet<StoricoAnagFasi> StoricoAnagFasis { get; set; }

        public virtual DbSet<StoricoAnagProgetti> StoricoAnagProgettis { get; set; }

        public virtual DbSet<TabWol> TabWols { get; set; }

        public virtual DbSet<Tally> Tallies { get; set; }

        public virtual DbSet<TimbratureExpl> TimbratureExpls { get; set; }

        public virtual DbSet<TransizioneEventi> TransizioneEventis { get; set; }
#endif

        #region Public Properties

        public virtual DbSet<AnagTipoTimb> DbSetAnagTipoTimb { get; set; }

        public virtual DbSet<CheckVc19> DbSetCheckVc19 { get; set; }
        public virtual DbSet<Dipendenti> DbSetDipendenti { get; set; }

        public virtual DbSet<Timbrature> DbSetTimbrature { get; set; }

        #endregion Public Properties

        #region Private Methods

        partial void OnModelCreatingPartial(ModelBuilder modelBuilder);

        #endregion Private Methods

        #region Protected Methods

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
                string connString = _configuration.GetConnectionString("Gpw.DB");
                if (!string.IsNullOrEmpty(connString))
                {
                    optionsBuilder.UseSqlServer(connString);
                }
                else
                {
                    optionsBuilder.UseSqlServer("Server=SQLSTEAM;Database=GPW;Trusted_Connection=True;");
                }
            }
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.HasAnnotation("Relational:Collation", "Latin1_General_CI_AS");

#if false
            modelBuilder.Entity<AnagClassiOrarie>(entity =>
              {
                  entity.HasKey(e => e.CodClasse);

                  entity.ToTable("AnagClassiOrarie");

                  entity.Property(e => e.CodClasse)
                      .HasMaxLength(10)
                      .HasColumnName("codClasse")
                      .HasComment("codice univoco");

                  entity.Property(e => e.DescrClasse)
                      .HasMaxLength(250)
                      .HasColumnName("descrClasse");

                  entity.Property(e => e.Peso)
                      .HasColumnType("decimal(6, 3)")
                      .HasColumnName("peso")
                      .HasComment("peso (per calcolo ore \"produttive\")");
              });

            modelBuilder.Entity<AnagClienti>(entity =>
            {
                entity.HasKey(e => e.IdxCliente);

                entity.ToTable("AnagClienti");

                entity.Property(e => e.IdxCliente).HasColumnName("idxCliente");

                entity.Property(e => e.Attivo).HasDefaultValueSql("((1))");

                entity.Property(e => e.Cap)
                    .HasMaxLength(5)
                    .HasColumnName("CAP");

                entity.Property(e => e.Cf)
                    .HasMaxLength(20)
                    .HasColumnName("CF");

                entity.Property(e => e.Citta)
                    .HasMaxLength(50)
                    .HasColumnName("citta");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(50)
                    .HasColumnName("codExt")
                    .HasDefaultValueSql("('n.d.')")
                    .HasComment("codice esterno");

                entity.Property(e => e.Email)
                    .HasMaxLength(50)
                    .HasColumnName("email");

                entity.Property(e => e.Indirizzo)
                    .HasMaxLength(50)
                    .HasColumnName("indirizzo");

                entity.Property(e => e.LogoUrl)
                    .HasMaxLength(50)
                    .HasColumnName("logoUrl");

                entity.Property(e => e.Nota)
                    .HasMaxLength(500)
                    .HasColumnName("nota");

                entity.Property(e => e.OldIdx).HasDefaultValueSql("((-1))");

                entity.Property(e => e.PIva)
                    .HasMaxLength(20)
                    .HasColumnName("pIva");

                entity.Property(e => e.Prov)
                    .HasMaxLength(50)
                    .HasColumnName("prov");

                entity.Property(e => e.RagSociale).HasMaxLength(250);

                entity.Property(e => e.Tel)
                    .HasMaxLength(50)
                    .HasColumnName("tel");

                entity.Property(e => e.Url)
                    .HasMaxLength(50)
                    .HasColumnName("url");
            });

            modelBuilder.Entity<AnagDevice>(entity =>
            {
                entity.HasKey(e => e.IdxDevice);

                entity.Property(e => e.DataOraEnabled)
                    .HasColumnType("datetime")
                    .HasColumnName("dataOraEnabled");

                entity.Property(e => e.DataOraLastSeen)
                    .HasColumnType("datetime")
                    .HasColumnName("dataOraLastSeen");

                entity.Property(e => e.Description).HasMaxLength(500);

                entity.Property(e => e.DeviceName)
                    .IsRequired()
                    .HasMaxLength(50);

                entity.Property(e => e.DeviceSecret)
                    .IsRequired()
                    .HasMaxLength(500);

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.LastIpv4)
                    .HasMaxLength(15)
                    .HasColumnName("lastIPv4");
            });

            modelBuilder.Entity<AnagFasi>(entity =>
            {
                entity.HasKey(e => e.IdxFase);

                entity.ToTable("AnagFasi");

                entity.HasIndex(e => new { e.IdxProgetto, e.Attivo }, "ix_AnagFasi_idxProgetto_Attivo");

                entity.Property(e => e.IdxFase).HasColumnName("idxFase");

                entity.Property(e => e.Attivo)
                    .IsRequired()
                    .HasDefaultValueSql("((1))");

                entity.Property(e => e.BudgetMoney)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("budgetMoney");

                entity.Property(e => e.BudgetTime)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("budgetTime")
                    .HasComment("Budget del progetto (in ore)");

                entity.Property(e => e.CodClasse)
                    .HasMaxLength(10)
                    .HasColumnName("codClasse")
                    .HasComment("codice univoco");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(50)
                    .HasColumnName("codExt")
                    .HasComment("codice esterno");

                entity.Property(e => e.CodFase)
                    .IsRequired()
                    .HasMaxLength(250)
                    .HasColumnName("codFase")
                    .HasComment("codice fase gerarchico (F.1.2. = Fase 1, sottofase 2) - aggiornare con trigger!");

                entity.Property(e => e.DescrizioneFase)
                    .HasMaxLength(250)
                    .HasColumnName("descrizioneFase");

                entity.Property(e => e.EnableMoney)
                    .HasColumnName("enableMoney")
                    .HasDefaultValueSql("((0))")
                    .HasComment("indica se sia abilitata o meno a ricevere assegnazioni di record di spesa");

                entity.Property(e => e.EnableTime)
                    .HasColumnName("enableTime")
                    .HasDefaultValueSql("((0))")
                    .HasComment("indica se sia abilitata o meno a ricevere assegnazioni di record temporali");

                entity.Property(e => e.IdxFaseAncest)
                    .HasColumnName("idxFaseAncest")
                    .HasComment("fase ANCESTOR (contenitore), 0 = è top level");

                entity.Property(e => e.IdxProgetto).HasColumnName("idxProgetto");

                entity.Property(e => e.NomeFase)
                    .HasMaxLength(250)
                    .HasColumnName("nomeFase");

                entity.HasOne(d => d.CodClasseNavigation)
                    .WithMany(p => p.AnagFasis)
                    .HasForeignKey(d => d.CodClasse)
                    .HasConstraintName("FK_AnagFasi_AnagClassiOrarie");

                entity.HasOne(d => d.IdxProgettoNavigation)
                    .WithMany(p => p.AnagFasis)
                    .HasForeignKey(d => d.IdxProgetto)
                    .HasConstraintName("FK_AnagFasi_AnagProgetti");
            });

            modelBuilder.Entity<AnagGiust>(entity =>
            {
                entity.HasKey(e => e.CodGiust);

                entity.ToTable("AnagGiust");

                entity.Property(e => e.CodGiust)
                    .HasMaxLength(5)
                    .HasColumnName("codGiust");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(50)
                    .HasColumnName("descrizione");

                entity.Property(e => e.UserSelectable)
                    .HasColumnName("userSelectable")
                    .HasDefaultValueSql("((1))");
            });

            modelBuilder.Entity<AnagKeyValue>(entity =>
            {
                entity.HasKey(e => e.NomeVar);

                entity.ToTable("AnagKeyValue");

                entity.Property(e => e.NomeVar)
                    .HasMaxLength(50)
                    .HasColumnName("nomeVar");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(250)
                    .HasColumnName("descrizione")
                    .HasDefaultValueSql("('-')");

                entity.Property(e => e.ValFloat)
                    .HasColumnName("valFloat")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.ValInt)
                    .HasColumnName("valInt")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.ValString)
                    .HasMaxLength(250)
                    .HasColumnName("valString")
                    .HasDefaultValueSql("('')");
            });

            modelBuilder.Entity<AnagProgetti>(entity =>
            {
                entity.HasKey(e => e.IdxProgetto);

                entity.ToTable("AnagProgetti");

                entity.Property(e => e.IdxProgetto).HasColumnName("idxProgetto");

                entity.Property(e => e.Attivo)
                    .IsRequired()
                    .HasDefaultValueSql("((1))");

                entity.Property(e => e.Avvio)
                    .HasColumnType("datetime")
                    .HasColumnName("avvio")
                    .HasDefaultValueSql("(getdate())");

                entity.Property(e => e.Chiusura)
                    .HasColumnType("datetime")
                    .HasColumnName("chiusura")
                    .HasDefaultValueSql("(dateadd(year,(10),getdate()))");

                entity.Property(e => e.CodExt)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("codExt")
                    .HasDefaultValueSql("('')")
                    .HasComment("codice esterno");

                entity.Property(e => e.DescrProj)
                    .IsRequired()
                    .HasMaxLength(250)
                    .HasColumnName("descrProj")
                    .HasDefaultValueSql("('-')");

                entity.Property(e => e.Gruppo)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("gruppo")
                    .HasDefaultValueSql("('STEAMWARE')");

                entity.Property(e => e.IdxCliente).HasColumnName("idxCliente");

                entity.Property(e => e.NomeProj)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("nomeProj");

                entity.Property(e => e.Starred).HasColumnName("starred");

                entity.HasOne(d => d.IdxClienteNavigation)
                    .WithMany(p => p.AnagProgettis)
                    .HasForeignKey(d => d.IdxCliente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_AnagProgetti_AnagClienti");
            });

            modelBuilder.Entity<AnagRuoli>(entity =>
            {
                entity.HasKey(e => e.CodRuolo);

                entity.ToTable("AnagRuoli");

                entity.Property(e => e.CodRuolo).HasMaxLength(50);

                entity.Property(e => e.DescrRuolo).HasMaxLength(50);
            });

            modelBuilder.Entity<AnagTipoCheck>(entity =>
            {
                entity.HasKey(e => e.ChkFun);

                entity.ToTable("AnagTipoCheck");

                entity.Property(e => e.ChkFun)
                    .HasMaxLength(50)
                    .HasColumnName("chkFun");

                entity.Property(e => e.DescrFun)
                    .HasMaxLength(50)
                    .HasColumnName("descrFun");
            });

            modelBuilder.Entity<AnagraficaEventi>(entity =>
            {
                entity.HasKey(e => e.IdxTipoEvento);

                entity.ToTable("AnagraficaEventi");

                entity.Property(e => e.IdxTipoEvento).ValueGeneratedNever();

                entity.Property(e => e.Nome).HasMaxLength(50);
            });

            modelBuilder.Entity<CalendFesteFerie>(entity =>
            {
                entity.HasKey(e => e.Data);

                entity.ToTable("CalendFesteFerie");

                entity.Property(e => e.Data)
                    .HasColumnType("date")
                    .HasColumnName("data");

                entity.Property(e => e.CodGiust)
                    .IsRequired()
                    .HasMaxLength(5)
                    .HasColumnName("codGiust")
                    .HasDefaultValueSql("('FEST')");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(50)
                    .HasColumnName("descrizione");
            });

            modelBuilder.Entity<Config>(entity =>
            {
                entity.HasKey(e => e.Chiave);

                entity.ToTable("Config");

                entity.Property(e => e.Chiave)
                    .HasMaxLength(50)
                    .HasColumnName("chiave");

                entity.Property(e => e.Note)
                    .HasMaxLength(250)
                    .HasColumnName("note");

                entity.Property(e => e.Valore)
                    .HasMaxLength(250)
                    .HasColumnName("valore");
            });

            modelBuilder.Entity<Contatori>(entity =>
            {
                entity.HasKey(e => e.CodContatore);

                entity.ToTable("Contatori");

                entity.Property(e => e.CodContatore)
                    .HasMaxLength(50)
                    .HasColumnName("codContatore")
                    .HasComment("codice di un contatore per uso specifico cliente");

                entity.Property(e => e.Valore).HasColumnName("valore");
            });

            modelBuilder.Entity<ControlloDefrag>(entity =>
            {
                entity.HasNoKey();

                entity.ToTable("ControlloDefrag");

                entity.Property(e => e.AvgFragmentationInPercent)
                    .HasColumnType("decimal(5, 2)")
                    .HasColumnName("avg_fragmentation_in_percent");

                entity.Property(e => e.CmdRebuild)
                    .HasMaxLength(410)
                    .HasColumnName("cmdREBUILD");

                entity.Property(e => e.CmdReorganize)
                    .HasMaxLength(413)
                    .HasColumnName("cmdREORGANIZE");

                entity.Property(e => e.Data).HasColumnType("datetime");

                entity.Property(e => e.Db)
                    .HasMaxLength(50)
                    .IsUnicode(false)
                    .HasColumnName("DB");

                entity.Property(e => e.FillFactor).HasColumnName("Fill_Factor");

                entity.Property(e => e.IndexName)
                    .HasMaxLength(128)
                    .HasColumnName("index_name");

                entity.Property(e => e.Oggetto)
                    .HasMaxLength(257)
                    .HasColumnName("oggetto");

                entity.Property(e => e.PageCount).HasColumnName("page_count");

                entity.Property(e => e.TypeDesc)
                    .HasMaxLength(60)
                    .HasColumnName("type_desc");
            });

            modelBuilder.Entity<Dipendenti2Ruoli>(entity =>
            {
                entity.HasKey(e => new { e.IdxDipendente, e.CodRuolo });

                entity.ToTable("Dipendenti2Ruoli");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.CodRuolo).HasMaxLength(50);
            });

            modelBuilder.Entity<ElencoReport>(entity =>
            {
                entity.HasKey(e => e.IdxRep);

                entity.ToTable("ElencoReport");

                entity.Property(e => e.Area)
                    .IsRequired()
                    .HasMaxLength(10)
                    .HasDefaultValueSql("(N'A1')");

                entity.Property(e => e.CssClass)
                    .HasMaxLength(250)
                    .HasColumnName("cssClass");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(250)
                    .HasColumnName("descrizione");

                entity.Property(e => e.Nome)
                    .HasMaxLength(50)
                    .HasColumnName("nome");

                entity.Property(e => e.ReportUrl).HasMaxLength(500);
            });

            modelBuilder.Entity<Funzioni>(entity =>
            {
                entity.HasKey(e => e.Funzione);

                entity.ToTable("Funzioni");

                entity.Property(e => e.Funzione)
                    .HasMaxLength(50)
                    .HasColumnName("funzione");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(250)
                    .HasColumnName("descrizione");
            });

            modelBuilder.Entity<Giustificativi>(entity =>
            {
                entity.HasKey(e => new { e.DataLav, e.IdxDipendente, e.CodGiust });

                entity.ToTable("Giustificativi");

                entity.Property(e => e.DataLav)
                    .HasColumnType("date")
                    .HasColumnName("dataLav");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.CodGiust)
                    .HasMaxLength(5)
                    .HasColumnName("codGiust");

                entity.Property(e => e.Automatico)
                    .HasColumnName("automatico")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.Minuti).HasColumnName("minuti");

                entity.HasOne(d => d.CodGiustNavigation)
                    .WithMany(p => p.Giustificativis)
                    .HasForeignKey(d => d.CodGiust)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_Giustificativi_AnagGiust");
            });

            modelBuilder.Entity<ImportEgaltech>(entity =>
            {
                entity.HasNoKey();

                entity.ToTable("ImportEgaltech");

                entity.Property(e => e.Commessa).HasMaxLength(50);

                entity.Property(e => e.Data).HasColumnType("date");

                entity.Property(e => e.DescRisultato).HasMaxLength(50);

                entity.Property(e => e.Fase).HasMaxLength(50);

                entity.Property(e => e.FlgCaricato).HasColumnName("flgCaricato");

                entity.Property(e => e.IdxRiga).ValueGeneratedOnAdd();

                entity.Property(e => e.NOre)
                    .HasColumnType("decimal(18, 4)")
                    .HasColumnName("nOre");

                entity.Property(e => e.Note).HasMaxLength(400);
            });

            modelBuilder.Entity<ImportEgaltechFase>(entity =>
            {
                entity.HasNoKey();

                entity.ToTable("ImportEgaltechFase");

                entity.Property(e => e.DescFase)
                    .IsRequired()
                    .HasMaxLength(50);

                entity.Property(e => e.Fase)
                    .IsRequired()
                    .HasMaxLength(10);
            });

            modelBuilder.Entity<ImportEgaltechNew>(entity =>
            {
                entity.HasNoKey();

                entity.ToTable("ImportEgaltechNew");

                entity.Property(e => e.Commessa).HasMaxLength(50);

                entity.Property(e => e.Data).HasColumnType("date");

                entity.Property(e => e.DescRisultato).HasMaxLength(50);

                entity.Property(e => e.Fase).HasMaxLength(50);

                entity.Property(e => e.FlgCaricato).HasColumnName("flgCaricato");

                entity.Property(e => e.IdxRiga).ValueGeneratedOnAdd();

                entity.Property(e => e.NOre)
                    .HasColumnType("decimal(18, 4)")
                    .HasColumnName("nOre");

                entity.Property(e => e.Note).HasMaxLength(400);

                entity.Property(e => e.SottoFase).HasMaxLength(50);
            });

            modelBuilder.Entity<ListValue>(entity =>
            {
                entity.HasKey(e => new { e.TableName, e.FieldName, e.Value })
                    .HasName("PK_ListValues_1");

                entity.Property(e => e.TableName).HasMaxLength(50);

                entity.Property(e => e.FieldName).HasMaxLength(50);

                entity.Property(e => e.Value)
                    .HasMaxLength(10)
                    .HasColumnName("value");

                entity.Property(e => e.Label)
                    .HasMaxLength(50)
                    .HasColumnName("label");

                entity.Property(e => e.Ordinal)
                    .HasColumnName("ordinal")
                    .HasDefaultValueSql("((0))");
            });

            modelBuilder.Entity<LogAttivitum>(entity =>
            {
                entity.HasKey(e => e.DataOra);

                entity.Property(e => e.DataOra).HasColumnType("datetime");

                entity.Property(e => e.Fonte)
                    .HasMaxLength(50)
                    .HasColumnName("fonte");

                entity.Property(e => e.Valore)
                    .HasMaxLength(500)
                    .HasColumnName("valore");
            });

            modelBuilder.Entity<LogUpdateDb>(entity =>
            {
                entity.HasKey(e => e.Versione);

                entity.ToTable("LogUpdateDb");

                entity.Property(e => e.Versione).ValueGeneratedNever();

                entity.Property(e => e.Data).HasColumnType("datetime");
            });

            modelBuilder.Entity<OreMensiliExport>(entity =>
            {
                entity.HasKey(e => new { e.IdxDipendente, e.DataLav });

                entity.ToTable("oreMensiliExport", "export");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.DataLav)
                    .HasColumnType("date")
                    .HasColumnName("dataLav");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(4)
                    .HasColumnName("codExt");

                entity.Property(e => e.Matricola)
                    .HasMaxLength(50)
                    .HasColumnName("matricola");

                entity.Property(e => e.MinFerieExp).HasColumnName("minFerieExp");

                entity.Property(e => e.MinFestExp).HasColumnName("minFestExp");

                entity.Property(e => e.MinLavOrdExp).HasColumnName("minLavOrdExp");

                entity.Property(e => e.MinLavStra).HasColumnName("minLavStra");

                entity.Property(e => e.MinLavTot).HasColumnName("minLavTot");

                entity.Property(e => e.MinMalExp).HasColumnName("minMalExp");

                entity.Property(e => e.MinPermExp).HasColumnName("minPermExp");

                entity.Property(e => e.MinPrevExp).HasColumnName("minPrevExp");

                entity.Property(e => e.MinStraExp).HasColumnName("minStraExp");

                entity.Property(e => e.MinStraProgrMese).HasColumnName("minStraProgrMese");

                entity.Property(e => e.OreStraordAss).HasColumnName("oreStraordAss");

                entity.Property(e => e.RifDitta).HasMaxLength(3);
            });

            modelBuilder.Entity<PeriodiLav>(entity =>
            {
                entity.HasKey(e => new { e.IdxDipendente, e.Entrata });

                entity.ToTable("PeriodiLav");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.Entrata)
                    .HasColumnType("datetime")
                    .HasColumnName("entrata");

                entity.Property(e => e.RowNum).HasColumnName("rowNum");

                entity.Property(e => e.Uscita)
                    .HasColumnType("datetime")
                    .HasColumnName("uscita");

                entity.HasOne(d => d.IdxDipendenteNavigation)
                    .WithMany(p => p.PeriodiLavs)
                    .HasForeignKey(d => d.IdxDipendente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_PeriodiLav_Dipendenti");
            });

            modelBuilder.Entity<Permessi>(entity =>
            {
                entity.HasKey(e => e.CodPermesso);

                entity.ToTable("Permessi");

                entity.Property(e => e.CodPermesso)
                    .HasMaxLength(50)
                    .IsUnicode(false)
                    .HasColumnName("COD_PERMESSO");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(50)
                    .IsUnicode(false)
                    .HasColumnName("DESCRIZIONE");

                entity.Property(e => e.Gruppo).HasColumnName("GRUPPO");

                entity.Property(e => e.Nome)
                    .HasMaxLength(50)
                    .IsUnicode(false)
                    .HasColumnName("NOME");

                entity.Property(e => e.Numero).HasColumnName("NUMERO");

                entity.Property(e => e.Url)
                    .IsRequired()
                    .HasMaxLength(250)
                    .IsUnicode(false)
                    .HasColumnName("URL");
            });

            modelBuilder.Entity<Permessi2Funzione>(entity =>
            {
                entity.HasKey(e => new { e.CodPermesso, e.CodFunzione });

                entity.ToTable("Permessi2Funzione");

                entity.Property(e => e.CodPermesso)
                    .HasMaxLength(50)
                    .IsUnicode(false)
                    .HasColumnName("COD_PERMESSO");

                entity.Property(e => e.CodFunzione)
                    .HasMaxLength(31)
                    .HasColumnName("COD_FUNZIONE");

                entity.Property(e => e.Readwrite)
                    .HasMaxLength(1)
                    .IsUnicode(false)
                    .HasColumnName("READWRITE")
                    .IsFixedLength(true);

                entity.HasOne(d => d.CodPermessoNavigation)
                    .WithMany(p => p.Permessi2Funziones)
                    .HasForeignKey(d => d.CodPermesso)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_Permessi2Funzione_Permessi");
            });

            modelBuilder.Entity<RegAttivitaEgal>(entity =>
            {
                entity.HasKey(e => e.IdxRa);

                entity.ToTable("RegAttivitaEgal");

                entity.Property(e => e.IdxRa).HasColumnName("idxRA");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(500)
                    .HasColumnName("descrizione");

                entity.Property(e => e.Fine)
                    .HasColumnType("datetime")
                    .HasColumnName("fine");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.IdxFase).HasColumnName("idxFase");

                entity.Property(e => e.Importo)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("importo")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.Inizio)
                    .HasColumnType("datetime")
                    .HasColumnName("inizio");

                entity.Property(e => e.OreTot)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("oreTot")
                    .HasComputedColumnSql("([dbo].[f_hourInterval]([inizio],[fine]))", false);

                entity.HasOne(d => d.IdxDipendenteNavigation)
                    .WithMany(p => p.RegAttivitaEgals)
                    .HasForeignKey(d => d.IdxDipendente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RegAttivita2_Dipendenti");

                entity.HasOne(d => d.IdxFaseNavigation)
                    .WithMany(p => p.RegAttivitaEgals)
                    .HasForeignKey(d => d.IdxFase)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RegAttivita2_AnagFasi");
            });

            modelBuilder.Entity<RegAttivitaExpl>(entity =>
            {
                entity.HasKey(e => new { e.DataLav, e.IdxDipendente });

                entity.ToTable("RegAttivitaExpl");

                entity.Property(e => e.DataLav)
                    .HasColumnType("date")
                    .HasColumnName("dataLav");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.CognomeNome)
                    .HasMaxLength(100)
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.DescrProj)
                    .HasMaxLength(500)
                    .HasColumnName("descrProj")
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.MinRegAtt)
                    .HasColumnName("minRegAtt")
                    .HasDefaultValueSql("((0))")
                    .HasComment("totale dei minuti di attività registrate per la giornata (da trigger suRegAttivita)");
            });

            modelBuilder.Entity<RegAttivitum>(entity =>
            {
                entity.HasKey(e => e.IdxRa);

                entity.HasIndex(e => e.Inizio, "ix_RA_inizio");

                entity.HasIndex(e => new { e.IdxDipendente, e.Inizio }, "ix_idxDip");

                entity.HasIndex(e => new { e.IdxFase, e.Inizio }, "ix_idxFase");

                entity.HasIndex(e => new { e.Inizio, e.IdxDipendente }, "ix_inizio");

                entity.Property(e => e.IdxRa).HasColumnName("idxRA");

                entity.Property(e => e.Descrizione)
                    .HasMaxLength(500)
                    .HasColumnName("descrizione");

                entity.Property(e => e.Fine)
                    .HasColumnType("datetime")
                    .HasColumnName("fine");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.IdxFase).HasColumnName("idxFase");

                entity.Property(e => e.Importo)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("importo")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.Inizio)
                    .HasColumnType("datetime")
                    .HasColumnName("inizio");

                entity.Property(e => e.OreTot)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("oreTot")
                    .HasComputedColumnSql("([dbo].[f_hourInterval]([inizio],[fine]))", false)
                    .HasComment("([dbo].[f_hourInterval]([inizio],[fine]))");

                entity.HasOne(d => d.IdxDipendenteNavigation)
                    .WithMany(p => p.RegAttivita)
                    .HasForeignKey(d => d.IdxDipendente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RegAttivita_Dipendenti");

                entity.HasOne(d => d.IdxFaseNavigation)
                    .WithMany(p => p.RegAttivita)
                    .HasForeignKey(d => d.IdxFase)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RegAttivita_AnagFasi");
            });

            modelBuilder.Entity<RegistroEventi>(entity =>
            {
                entity.HasKey(e => new { e.DataOra, e.Evento });

                entity.ToTable("RegistroEventi");

                entity.Property(e => e.DataOra).HasColumnType("datetime");

                entity.Property(e => e.Evento)
                    .HasMaxLength(50)
                    .HasColumnName("evento");

                entity.Property(e => e.Commento)
                    .HasMaxLength(250)
                    .HasColumnName("commento");
            });

            modelBuilder.Entity<RilievoTemp>(entity =>
            {
                entity.HasKey(e => new { e.IdxDipendente, e.DtRilievo });

                entity.ToTable("RilievoTemp");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.DtRilievo)
                    .HasColumnType("datetime")
                    .HasColumnName("dtRilievo");

                entity.Property(e => e.TempRil)
                    .HasColumnType("decimal(9, 3)")
                    .HasColumnName("tempRil");

                entity.HasOne(d => d.IdxDipendenteNavigation)
                    .WithMany(p => p.RilievoTemps)
                    .HasForeignKey(d => d.IdxDipendente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RilievoTemp_Dipendenti");
            });

            modelBuilder.Entity<Sottoscrizioni>(entity =>
            {
                entity.HasKey(e => e.SubscriptionId)
                    .HasName("PK__Sottoscr__9A2B24BD00200768");

                entity.ToTable("Sottoscrizioni");

                entity.Property(e => e.SubscriptionId)
                    .ValueGeneratedNever()
                    .HasColumnName("SubscriptionID");

                entity.Property(e => e.DataFine).HasColumnType("smalldatetime");

                entity.Property(e => e.DataInizio).HasColumnType("smalldatetime");

                entity.Property(e => e.EMail)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("eMail");

                entity.Property(e => e.Format)
                    .IsRequired()
                    .HasMaxLength(20);

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.SubscriptionName)
                    .IsRequired()
                    .HasMaxLength(50);
            });

            modelBuilder.Entity<StoricoAnagFasi>(entity =>
            {
                entity.HasKey(e => e.IdxEv);

                entity.ToTable("Storico_AnagFasi");

                entity.Property(e => e.IdxEv).HasColumnName("idxEv");

                entity.Property(e => e.Attivo).HasDefaultValueSql("((1))");

                entity.Property(e => e.BudgetMoney)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("budgetMoney");

                entity.Property(e => e.BudgetTime)
                    .HasColumnType("decimal(19, 4)")
                    .HasColumnName("budgetTime")
                    .HasComment("Budget del progetto (in ore)");

                entity.Property(e => e.CodClasse)
                    .HasMaxLength(10)
                    .HasColumnName("codClasse")
                    .HasComment("codice univoco");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(50)
                    .HasColumnName("codExt")
                    .HasComment("codice esterno");

                entity.Property(e => e.CodFase)
                    .HasMaxLength(250)
                    .HasColumnName("codFase")
                    .HasComment("codice fase gerarchico (F.1.2. = Fase 1, sottofase 2) - aggiornare con trigger!");

                entity.Property(e => e.DataEv).HasColumnType("datetime");

                entity.Property(e => e.DescrizioneFase)
                    .HasMaxLength(250)
                    .HasColumnName("descrizioneFase");

                entity.Property(e => e.EnableMoney)
                    .HasColumnName("enableMoney")
                    .HasDefaultValueSql("((0))")
                    .HasComment("indica se sia abilitata o meno a ricevere assegnazioni di record di spesa");

                entity.Property(e => e.EnableTime)
                    .HasColumnName("enableTime")
                    .HasDefaultValueSql("((0))")
                    .HasComment("indica se sia abilitata o meno a ricevere assegnazioni di record temporali");

                entity.Property(e => e.IdxFase).HasColumnName("idxFase");

                entity.Property(e => e.IdxFaseAncest)
                    .HasColumnName("idxFaseAncest")
                    .HasDefaultValueSql("((0))")
                    .HasComment("fase ANCESTOR (contenitore), 0 = è top level");

                entity.Property(e => e.IdxProgetto).HasColumnName("idxProgetto");

                entity.Property(e => e.NomeFase)
                    .HasMaxLength(250)
                    .HasColumnName("nomeFase");
            });

            modelBuilder.Entity<StoricoAnagProgetti>(entity =>
            {
                entity.HasKey(e => e.IdxEv);

                entity.ToTable("Storico_AnagProgetti");

                entity.Property(e => e.IdxEv).HasColumnName("idxEv");

                entity.Property(e => e.Attivo).HasDefaultValueSql("((1))");

                entity.Property(e => e.Avvio)
                    .HasColumnType("datetime")
                    .HasColumnName("avvio");

                entity.Property(e => e.Chiusura)
                    .HasColumnType("datetime")
                    .HasColumnName("chiusura");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(50)
                    .HasColumnName("codExt")
                    .HasComment("codice esterno");

                entity.Property(e => e.DataEv).HasColumnType("datetime");

                entity.Property(e => e.DescrProj)
                    .HasMaxLength(250)
                    .HasColumnName("descrProj");

                entity.Property(e => e.Gruppo)
                    .HasMaxLength(50)
                    .HasColumnName("gruppo")
                    .HasDefaultValueSql("('STEAMWARE')");

                entity.Property(e => e.IdxCliente).HasColumnName("idxCliente");

                entity.Property(e => e.IdxProgetto).HasColumnName("idxProgetto");

                entity.Property(e => e.NomeProj)
                    .HasMaxLength(50)
                    .HasColumnName("nomeProj");

                entity.Property(e => e.Starred).HasColumnName("starred");
            });

            modelBuilder.Entity<TabWol>(entity =>
            {
                entity.HasKey(e => e.IdxDipendente);

                entity.ToTable("TabWOL");

                entity.Property(e => e.IdxDipendente)
                    .ValueGeneratedNever()
                    .HasColumnName("idxDipendente");
            });

            modelBuilder.Entity<Tally>(entity =>
            {
                entity.HasKey(e => e.N)
                    .HasName("PK_Tally_N");

                entity.ToTable("Tally");
            });

            modelBuilder.Entity<TimbratureExpl>(entity =>
            {
                entity.HasKey(e => new { e.DataLav, e.IdxDipendente })
                    .HasName("PK_TimbratureExpl_1");

                entity.ToTable("TimbratureExpl");

                entity.HasIndex(e => new { e.CognomeNome, e.DataLav }, "ix_TimbrExpl_CognomeNome_DataLav");

                entity.HasIndex(e => e.IdxDipendente, "ix_idxDip");

                entity.Property(e => e.DataLav)
                    .HasColumnType("date")
                    .HasColumnName("dataLav");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.Block)
                    .HasColumnName("block")
                    .HasDefaultValueSql("((0))")
                    .HasComment("determina se il record sia \"bloccato\" (archiviazione e blocco mesi precedenti...)");

                entity.Property(e => e.ChkFunCod)
                    .HasMaxLength(50)
                    .HasColumnName("chkFunCod")
                    .HasDefaultValueSql("('')")
                    .HasComment("eventuale diagnostica da check function sulla riga indicata (codice)");

                entity.Property(e => e.ChkFunRes)
                    .HasMaxLength(50)
                    .HasColumnName("chkFunRes")
                    .HasDefaultValueSql("('')")
                    .HasComment("eventuale diagnostica da check function sulla riga indicata (spiegazione)");

                entity.Property(e => e.CognomeNome).HasMaxLength(100);

                entity.Property(e => e.Entrata1)
                    .HasColumnType("datetime")
                    .HasColumnName("entrata_1");

                entity.Property(e => e.Entrata2)
                    .HasColumnType("datetime")
                    .HasColumnName("entrata_2");

                entity.Property(e => e.Entrata3)
                    .HasColumnType("datetime")
                    .HasColumnName("entrata_3");

                entity.Property(e => e.Entrata4)
                    .HasColumnType("datetime")
                    .HasColumnName("entrata_4");

                entity.Property(e => e.HGiust)
                    .HasColumnName("h_giust")
                    .HasComputedColumnSql("(((((((CONVERT([float],[minPerm],(0))+[minFer])+[minMal])+[minFest])+[min104])+[minMpp])+[minCassa])/(60))", false)
                    .HasComment("totale ore giustificate");

                entity.Property(e => e.HLav).HasColumnName("h_lav");

                entity.Property(e => e.IsOk)
                    .HasColumnName("isOk")
                    .HasComputedColumnSql("(([isOkTim]&[isOkApp])&case when [minOrd]<=((((((([minLav]+[minPerm])+[minFer])+[minMal])+[minFest])+[minCassa])+[min104])+[minMpp]) then (1) else (0) end)", false);

                entity.Property(e => e.IsOkApp)
                    .HasColumnName("isOkApp")
                    .HasDefaultValueSql("((1))")
                    .HasComment("dato sintetico x indicare se TUTTE le timbrature componenti siano approvate");

                entity.Property(e => e.IsOkLav)
                    .HasColumnName("isOkLav")
                    .HasComputedColumnSql("(case when [minOrd]<=((((((([minLav]+[minPerm])+[minFer])+[minMal])+[minFest])+[minCassa])+[min104])+[minMpp]) then (1) else (0) end)", false)
                    .HasComment("determina se la giornata sia ok (oreLav + giustificativi >= oreOrd)");

                entity.Property(e => e.IsOkTim)
                    .HasColumnName("isOkTim")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.Min104)
                    .HasColumnName("min104")
                    .HasDefaultValueSql("((0))")
                    .HasComment("Minuti Permessi per 104");

                entity.Property(e => e.MinArcoPres)
                    .HasColumnName("minArcoPres")
                    .HasComputedColumnSql("(datediff(minute,isnull([entrata_1],getdate()),isnull(isnull([uscita_4],isnull([uscita_3],isnull([uscita_2],isnull([uscita_1],[entrata_1])))),getdate())))", false)
                    .HasComment("DATEDIFF(n, ISNULL(entrata_1,GETDATE()), ISNULL(ISNULL(uscita_4,ISNULL(uscita_3,ISNULL(uscita_2,ISNULL(uscita_1,entrata_1)))),GETDATE()))");

                entity.Property(e => e.MinCassa)
                    .HasColumnName("minCassa")
                    .HasDefaultValueSql("((0))")
                    .HasComment("Minuti di Cassa Integrazione");

                entity.Property(e => e.MinFer)
                    .HasColumnName("minFer")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinFest)
                    .HasColumnName("minFest")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinLav)
                    .HasColumnName("minLav")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinMal)
                    .HasColumnName("minMal")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinMpp)
                    .HasColumnName("minMpp")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinNonLav)
                    .HasColumnName("minNonLav")
                    .HasDefaultValueSql("((0))")
                    .HasComment("minuti non lavorati (ovvero se fatti meno di ordinari e senza giustificativi)");

                entity.Property(e => e.MinOrd)
                    .HasColumnName("minOrd")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinPerm)
                    .HasColumnName("minPerm")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MinStra)
                    .HasColumnName("minStra")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.TempRil)
                    .HasColumnType("decimal(9, 3)")
                    .HasColumnName("tempRil")
                    .HasComment("Temperatura rilevata");

                entity.Property(e => e.Uscita1)
                    .HasColumnType("datetime")
                    .HasColumnName("uscita_1");

                entity.Property(e => e.Uscita2)
                    .HasColumnType("datetime")
                    .HasColumnName("uscita_2");

                entity.Property(e => e.Uscita3)
                    .HasColumnType("datetime")
                    .HasColumnName("uscita_3");

                entity.Property(e => e.Uscita4)
                    .HasColumnType("datetime")
                    .HasColumnName("uscita_4");
            });

            modelBuilder.Entity<TransizioneEventi>(entity =>
            {
                entity.HasKey(e => e.CodInviato);

                entity.ToTable("TransizioneEventi");

                entity.Property(e => e.CodInviato)
                    .HasMaxLength(50)
                    .HasColumnName("codInviato");

                entity.Property(e => e.DescrComando)
                    .HasMaxLength(250)
                    .HasColumnName("descrComando");

                entity.Property(e => e.PrecCodInviato)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("prec_codInviato")
                    .HasDefaultValueSql("(N'-')");

                entity.Property(e => e.Text2show)
                    .HasMaxLength(500)
                    .HasColumnName("text2show");

                entity.HasOne(d => d.IdxTipoEventoNavigation)
                    .WithMany(p => p.TransizioneEventis)
                    .HasForeignKey(d => d.IdxTipoEvento)
                    .HasConstraintName("FK_TransizioneEventi_AnagraficaEventi");
            });
#endif

            modelBuilder.Entity<AnagGruppi>(entity =>
            {
                entity.HasKey(e => e.Gruppo);

                entity.ToTable("AnagGruppi");

                entity.Property(e => e.Gruppo)
                    .HasMaxLength(50)
                    .HasColumnName("gruppo");

                entity.Property(e => e.CodExt)
                    .HasMaxLength(4)
                    .HasColumnName("codExt");

                entity.Property(e => e.DescrGruppo)
                    .HasMaxLength(50)
                    .HasColumnName("descrGruppo");

                entity.Property(e => e.ExportEnab)
                    .HasColumnName("exportEnab")
                    .HasDefaultValueSql("((1))")
                    .HasComment("determina se sia abilitato x export dati");
            });

            modelBuilder.Entity<AnagOrari>(entity =>
            {
                entity.HasKey(e => e.CodOrario);

                entity.ToTable("AnagOrari");

                entity.Property(e => e.CodOrario)
                    .HasMaxLength(50)
                    .HasColumnName("codOrario");

                entity.Property(e => e.ArrotMinuti)
                    .HasColumnName("arrotMinuti")
                    .HasDefaultValueSql("((1))");

                entity.Property(e => e.AutoCompOreOrd)
                    .HasColumnName("autoCompOreOrd")
                    .HasComment("indica se ci sia compensazione automatica delle ore (ordinarie) lavorate (prelevando da straordinarie)");

                entity.Property(e => e.ChkFun)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("chkFun")
                    .HasDefaultValueSql("('')")
                    .HasComment("parametro (opzionale) da passare alla funzione di check \"finale\" per verifica giornate lavorate in tab TimbratureExpl");

                entity.Property(e => e.DescOrario)
                    .IsRequired()
                    .HasMaxLength(250)
                    .HasColumnName("descOrario")
                    .HasDefaultValueSql("('--descrizione--')");

                entity.Property(e => e.OraFine1).HasColumnName("oraFine_1");

                entity.Property(e => e.OraFine2).HasColumnName("oraFine_2");

                entity.Property(e => e.OraFine3).HasColumnName("oraFine_3");

                entity.Property(e => e.OraInizio1).HasColumnName("oraInizio_1");

                entity.Property(e => e.OraInizio2).HasColumnName("oraInizio_2");

                entity.Property(e => e.OraInizio3).HasColumnName("oraInizio_3");

                entity.Property(e => e.OreDom).HasColumnName("oreDom");

                entity.Property(e => e.OreGio).HasColumnName("oreGio");

                entity.Property(e => e.OreLun).HasColumnName("oreLun");

                entity.Property(e => e.OreMar).HasColumnName("oreMar");

                entity.Property(e => e.OreMer).HasColumnName("oreMer");

                entity.Property(e => e.OreOrdSett)
                    .HasColumnName("oreOrdSett")
                    .HasComputedColumnSql("(((((([oreLun]+[oreMar])+[oreMer])+[oreGio])+[oreVen])+[oreSab])+[oreDom])", false);

                entity.Property(e => e.OreSab).HasColumnName("oreSab");

                entity.Property(e => e.OreStraordAss).HasColumnName("oreStraordAss");

                entity.Property(e => e.OreVen).HasColumnName("oreVen");

                entity.Property(e => e.TipoCompens)
                    .IsRequired()
                    .HasMaxLength(2)
                    .HasColumnName("tipoCompens")
                    .HasDefaultValueSql("('M')")
                    .HasComment("indica il tipo di compensazione automatica delle ore --> M = mese, W = settimana");
            });

            modelBuilder.Entity<AnagTipoTimb>(entity =>
            {
                entity.HasKey(e => e.CodTipoTimb);

                entity.ToTable("AnagTipoTimb");

                entity.Property(e => e.CodTipoTimb).HasMaxLength(10);

                entity.Property(e => e.DescrTipoTimb).HasMaxLength(500);
            });

            modelBuilder.Entity<CheckVc19>(entity =>
            {
                entity.HasKey(e => e.IdxCheckVc19);

                entity.ToTable("CheckVC19");

                entity.Property(e => e.DtCheck)
                    .HasColumnType("datetime")
                    .HasColumnName("dtCheck")
                    .HasDefaultValueSql("(getdate())");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.Payload)
                    .IsRequired()
                    .HasMaxLength(500)
                    .HasColumnName("payload")
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.Cognome)
                    .IsRequired()
                    .HasMaxLength(100)
                    .HasColumnName("cognome")
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.Nome)
                    .IsRequired()
                    .HasMaxLength(100)
                    .HasColumnName("nome")
                    .HasDefaultValueSql("('')");
            });

            modelBuilder.Entity<Dipendenti>(entity =>
            {
                entity.HasKey(e => e.IdxDipendente);

                entity.ToTable("Dipendenti");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.Attivo)
                    .HasColumnName("attivo")
                    .HasDefaultValueSql("((1))");

                entity.Property(e => e.AuthKey)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("authKey")
                    .HasDefaultValueSql("('##########')");

                entity.Property(e => e.Cf)
                    .IsRequired()
                    .HasMaxLength(16)
                    .HasColumnName("CF")
                    .HasDefaultValueSql("('0000000000000000')");

                entity.Property(e => e.CodDipendenteExt)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("codDipendenteExt")
                    .HasDefaultValueSql("('')")
                    .HasComment("nome/codice dipendente per sistema esterno da importare");

                entity.Property(e => e.CodHw)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("codHw")
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.CodOrario)
                    .HasMaxLength(50)
                    .HasColumnName("codOrario");

                entity.Property(e => e.Cognome).HasMaxLength(50);

                entity.Property(e => e.DataAssunzione)
                    .HasColumnType("date")
                    .HasColumnName("dataAssunzione")
                    .HasDefaultValueSql("('1900-01-01')");

                entity.Property(e => e.DataCessazione)
                    .HasColumnType("date")
                    .HasColumnName("dataCessazione")
                    .HasDefaultValueSql("('9999-12-31')");

                entity.Property(e => e.DataNascita)
                    .HasColumnType("datetime")
                    .HasColumnName("dataNascita");

                entity.Property(e => e.Dominio)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("dominio")
                    .HasDefaultValueSql("('DOMINIO')");

                entity.Property(e => e.Email)
                    .IsRequired()
                    .HasMaxLength(250)
                    .HasColumnName("email")
                    .HasDefaultValueSql("('')");

                entity.Property(e => e.Gruppo)
                    .HasMaxLength(50)
                    .HasColumnName("gruppo")
                    .HasDefaultValueSql("('NA')");

                entity.Property(e => e.LuogoNascita)
                    .HasMaxLength(50)
                    .HasColumnName("luogoNascita");

                entity.Property(e => e.MailDay)
                    .HasColumnName("mailDay")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MailLastOp)
                    .HasColumnName("mailLastOp")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MailMonth)
                    .HasColumnName("mailMonth")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.MailWeek)
                    .HasColumnName("mailWeek")
                    .HasDefaultValueSql("((0))");

                entity.Property(e => e.Matricola)
                    .HasMaxLength(50)
                    .HasColumnName("matricola");

                entity.Property(e => e.NazNascita)
                    .HasMaxLength(50)
                    .HasColumnName("nazNascita");

                entity.Property(e => e.Nome).HasMaxLength(50);

                entity.Property(e => e.NumAuth)
                    .HasColumnName("numAuth")
                    .HasDefaultValueSql("((0))")
                    .HasComment("numero di impieghi della authKey");

                entity.Property(e => e.ProvNascita)
                    .HasMaxLength(50)
                    .HasColumnName("provNascita");

                entity.Property(e => e.Utente)
                    .IsRequired()
                    .HasMaxLength(50)
                    .HasColumnName("utente")
                    .HasDefaultValueSql("('UTENTE')");

                entity.Property(e => e.WolMac)
                    .HasMaxLength(50)
                    .HasColumnName("WOL_MAC");

                entity.HasOne(d => d.CodOrarioNavigation)
                    .WithMany(p => p.DipendentiNav)
                    .HasForeignKey(d => d.CodOrario)
                    .HasConstraintName("FK_Dipendenti_AnagOrari");

                entity.HasOne(d => d.GruppoNavigation)
                    .WithMany(p => p.DipendentiNav)
                    .HasForeignKey(d => d.Gruppo)
                    .HasConstraintName("FK_Dipendenti_AnagGruppi");
            });

            modelBuilder.Entity<Timbrature>(entity =>
            {
                entity.HasKey(e => new { e.IdxDipendente, e.DataOra });

                entity.ToTable("Timbrature");

                entity.HasIndex(e => new { e.IdxDipendente, e.Entrata }, "ix_Timbrature_IdxDip_Entrata");

                entity.Property(e => e.IdxDipendente).HasColumnName("idxDipendente");

                entity.Property(e => e.DataOra)
                    .HasColumnType("datetime")
                    .HasColumnName("dataOra");

                entity.Property(e => e.Approv)
                    .HasDefaultValueSql("((0))")
                    .HasComment("Approvazioen timbratura (default true...)");

                entity.Property(e => e.CodTipoTimb)
                    .HasMaxLength(10)
                    .HasDefaultValueSql("(N'BC')");

                entity.Property(e => e.Entrata).HasColumnName("entrata");

                entity.Property(e => e.Ipv4)
                    .HasMaxLength(15)
                    .HasColumnName("IPv4")
                    .HasDefaultValueSql("(N'0.0.0.0')");

                entity.HasOne(d => d.CodTipoTimbNav)
                    .WithMany(p => p.TimbratureNav)
                    .HasForeignKey(d => d.CodTipoTimb)
                    .HasConstraintName("FK_Timbrature_AnagTipoTimb");

                entity.HasOne(d => d.DipNav)
                    .WithMany(p => p.TimbratureNav)
                    .HasForeignKey(d => d.IdxDipendente)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_Timbrature_Dipendenti");
            });

            OnModelCreatingPartial(modelBuilder);
        }

        #endregion Protected Methods

        #region Public Methods

        public void DbForceMigrate()
        {
            try
            {
                // se non ci fosse... crea o migra!
                Database.Migrate();
                Log.Info("DbForceMigrate: done!");
            }
            catch (Exception exc)
            {
                Log.Error(exc, "DbForceMigrate: Exception during context initialization 01");
            }
        }

        #endregion Public Methods
    }
}