52 messaggi dal 12 settembre 2010
Ciao a tutti,
all'interno di un controller ho riportato la seguente porzione di codice:
const string sessionKey = "FirstSeen";
            DateTime dateFirstSeen;
            var value = HttpContext.Session.GetString(sessionKey);
            if (string.IsNullOrEmpty(value))
            {
                dateFirstSeen = DateTime.Now;
                var serialisedDate = JsonConvert.SerializeObject(dateFirstSeen);
                HttpContext.Session.SetString(sessionKey, serialisedDate);
            }
            else
            {
                dateFirstSeen = JsonConvert.DeserializeObject<DateTime>(value);
            }
            var testSession = new TestSession()
            {
                DateSessionStarted = dateFirstSeen,
                Now = DateTime.Now
            };


In modo tale che tramite la View faccio stampare l'ora corrente e l'ora in cui è stata inizializzata la sessione per la chiave "FirstSeen"...fin qui tutto ok...ho notato però che mantenendo abilitato nel file "Startup.cs" la seguente riga:
app.UseCookiePolicy();


La sessione e l'ora corrente sono sempre uguali...questo fino a quando direttamente dalla view non confermo il consenso sulla privacy policy...da quel momento in poi tutto funziona regolarmente...è normale questo tipo di comportamento?
Volendo gestire la sessione in questo modo, ovvero facendo della libreria "Microsoft.AspNetCore.Session", posso tranquillamente rimuovere dal file "Startup.cs" la riga sul cookie policy?

Vi ringrazio in anticipo!!!
11.050 messaggi dal 09 febbraio 2002
Contributi
Ciao,
abilitando il middleware della cookie policy fai in modo che l'applicazione ASP.NET Core non possa emettere cookie "non essenziali" finché l'utente non dà la sua approvazione.

Dato che la sessione è basata sui cookie, e dato che questi cookie sono considerati "non essenziali", non funzionerà finché l'utente non dà la sua approvazione all'uso dei cookie.
Puoi leggere qui:
https://docs.microsoft.com/en-us/aspnet/core/security/gdpr?view=aspnetcore-2.1#tempdata-provider-and-session-state-cookies-are-not-essential


posso tranquillamente rimuovere dal file "Startup.cs" la riga sul cookie policy?

Sarebbe meglio di no, perché è stata introdotta per conformità al GDPR. Piuttosto, rinuncia ad usare la sessione. A che ti serve?

ciao,
Moreno

Enjoy learning and just keep making
52 messaggi dal 12 settembre 2010
Ciao Moreno,
ho bisogno della sessione per poter mantenere i dati di un utenza loggata...sto realizzando un progetto con ASP.NET Core 2 e DB MySql e non so come fare...oltre a delle guide online sto cercando di seguire anche le indicazioni del vostro libro (ASP.NET Core 2 - Guida completa per lo sviluppatore) facendo riferimento al capitolo 17 dove si parla di autenticazione, autorizzazione e identità ma non capisco se usando un DB MySql posso comunque percorrere questa strada o meno...

Grazie,
Alessio.
11.050 messaggi dal 09 febbraio 2002
Contributi
Ciao Alessio,


facendo riferimento al capitolo 17 dove si parla di autenticazione, autorizzazione e identità ma non capisco se usando un DB MySql posso comunque percorrere questa strada o meno...

Assolutamente sì perché ASP.NET Core Identity si avvale di Entity Framework Core per persistere gli utenti. Entity Framework Core può funzionare anche con MySql grazie all'apposito provider fornito come pacchetto NuGet che dovrai installare nel tuo progetto.

Il capitolo 17 l'ho scritto io quindi ti posso fornire tutti i chiarimenti che desideri.

Le sessione dimenticala per questo scopo. Si usava nel 1999 con ASP classico.

ciao,
Moreno

Enjoy learning and just keep making
52 messaggi dal 12 settembre 2010
Ciao Moreno,
ok ho installato i seguenti pacchetti nel mio progetto:
- Microsoft.AspNetCore.Identity.UI
- credo mi serva per personalizzare la view delle form di registrazione e login giusto? non esiste un altro modo per richiamarle ed accedervi come se fossero semplici viste gestite secondo la logica MVC?
- Microsoft.EntityFrameworkCore.Design
- Microsoft.EntityFrameworkCore.Tools
. MySql.Data.EntityFrameworkCore

Ora mi sembra di trovarmi in "alto mare"...cioè ho provato anche a seguire questa guida https://retifrav.github.io/blog/2018/03/20/csharp-dotnet-core-identity-mysql/ ma come arrivo in questo punto:
I did not create my own ApplicationUser class, because I decided to take the default IdentityUser, so I replaced it in views Login.cshtml and _LoginPartial.cshtml and also changed the AccountController (and ManageController) constructor as follows

praticamente mi sento già perso...non capisco da dove prende le viste di cui parla (istanziando da VS2017 un nuovo progetto con autenticazione io non le trovo) e poi parla delle modifiche al costruttore di "AccountController" (ManageController sarebbe la stessa cosa?) :(
11.050 messaggi dal 09 febbraio 2002
Contributi
Ciao,


non capisco da dove prende le viste di cui parla (istanziando da VS2017 un nuovo progetto con autenticazione io non le trovo)

E' normale perché Microsoft da ASP.NET Core 2 ha inserito quelle view nel pacchetto NuGet Microsoft.AspNetCore.Identity.UI e quindi non le troverai come file nel progetto. Microsoft ha fatto questa scelta perché ha reputato più importante che le view venissero veicolate come pacchetto e perciò potessero essere facilmente aggiornate in caso di problemi di sicurezza. Del resto si tratta di view molto delicate, che riguardano login, registrazione e gestione del profilo e dalle quali passa anche la protezione dell'account dell'utente.
Non dev'essere stata una scelta semplice perché c'è una grossa controindicazione: chi si avvicina per la prima volta ad ASP.NET Core può restare spaesato e chiedersi dove cavolo siano queste view che vengono visualizzate quando si vista (ad esempio) Identity/Account/Login.
Ora sai che stanno nell'assembly fornito col pacchetto Microsoft.AspNetCore.Identity.UI e, se necessario, le puoi ri-aggiungere al progetto come ho descritto a pagina 361 del libro.

Comunque, secondo me non hai bisogno di modificare queste view. Mi sembra che l'articolo che hai trovato spieghi la faccenda in maniera molto più complicata del necessario.

Le tappe sono queste:
  • Da Visual Studio, crei un nuovo progetto ASP.NET Core 2.1 con autenticazione con account utente individuali (cosa che hai già fatto);
  • Installa i pacchetti Pomelo.EntityFrameworkCore.MySql e Pomelo.EntityFrameworkCore.MySql.Design. Prima ti avevo consigliato quelli di Oracle ma sembra che questi abbiano un supporto migliore alle migrations;
  • Vai nella classe Startup e trova il punto in cui c'è la registrazione del DbContext (intorno alla riga 37). Sostituisci UseSqlServer con UseMySql:
     services.AddDbContext<ApplicationDbContext>(options =>
                    options.UseMySql(
                        Configuration.GetConnectionString("DefaultConnection")));
    
  • Vai nel file appsettings.json e modifica la connection string. Ovviamente deve essere la connection string a un database mysql. Ad esempio:
    "ConnectionStrings": {
        "DefaultConnection": "Server=localhost; Database=test; User=root; Password=root;"
      }
    
  • Adesso dobbiamo creare le tabelle sul database MySql. Affinché questa operazione vada a buon fine è necessario che l'utente di MySql che hai indicato nella connection string abbia i privilegi di creazione delle tabelle.
    Elimina la directory Data/Migrations, perché quelle non sono migrations per MySql e ricreale da riga di comando eseguendo quanto segue dalla directory principale del progetto:
    dotnet ef migrations add "Prima migration"
    dotnet database update
    

    Grazie a questi due comandi ti verranno create le tabelle necessarie.
  • Avvia l'applicazione e prova a registrare un utente. Enjoy!



praticamente mi sento già perso..

E' normale perché ASP.NET Core Identity ha una certa curva d'apprendimento ma è uno strumento essenziale per affrontare in maniera appropriata il problema del login degli utenti.

ciao,
Moreno

Enjoy learning and just keep making
52 messaggi dal 12 settembre 2010
Ciao Moreno,
entro sera proverò sicuramente a seguire i tuoi suggerimenti e le tue indicazioni (intanto ti ringrazio veramente tanto!!!).

Il progetto era già stato creato (senza autenticazione) quindi sto inserendo adesso il necessario...dato che provengo da questa discussione http://forum.aspitalia.com/forum/post/420941/Connessione-DB-MySql.aspx in questo momento sto impostando il file di "Startup.cs" in questo modo:
public class Startup
    {
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                          .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                          .AddEnvironmentVariables();

            Configuration = builder.Build();
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddDbContext<DbContext>(options => options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));
            services.AddScoped<BackEndContext>();

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                app.UseHsts();
            }

            //app.UseHttpsRedirection();
            app.UseStaticFiles();
            app.UseCookiePolicy();

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "area",
                    template: "{area:exists}/{controller=Admin}/{action=Index}/{id?}");

                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }


Ora questa riga
services.AddScoped<BackEndContext>();
l'avevo inserita seguendo le indicazioni che mi avevi dato nell'altro post e il tutto funziona regolarmente...quindi mi chiedo:
1) - i due richiami al dbcontext possono coesistere oppure non è necessario usarli entrambi? Mi riferisco a
services.AddDbContext<DbContext>(options => options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped<BackEndContext>();


In questo momento il file "BackEndContext" è configurato in questo modo:
public class BackEndContext
    {
        public string ConnectionString { get; set; }

        public BackEndContext(IConfiguration configuration)
        {
            this.ConnectionString = configuration.GetConnectionString("DefaultConnection");
        }

        private MySqlConnection GetConnection() => new MySqlConnection(ConnectionString);

        public List<Utenti> GetAllUtenti()
        {
            Dictionary<string, object> p = new Dictionary<string, object>();

            List<Utenti> list = SQLHelper.FillByQueryName(enQueries.BackEnd_Utenti, p, GetConnection()).ConvertDataTableToGenericList<Utenti>();

            return list;
        }
    }


Grazie in anticipo!!!
11.050 messaggi dal 09 febbraio 2002
Contributi
Ciao, prego!


- i due richiami al dbcontext

Non sono due dbcontext. Uno è una classe chiamata "BackEndContext" che usa MySqlConnection e le altre classi di ADO.NET per accedere al database.
L'altro, chiamato ApplicationDbContext, è una classe che deriva da DbContext e che perciò usa Entity Framework Core per accedere al db.

Credo che questo non sia corretto:
services.AddDbContext<DbContext>(...);

Devi usare il nome della classe ApplicationDbContext (o qualsiasi sia il nome della tua classe che deriva da DbContext. Quindi:
services.AddDbContext<ApplicationDbContext>(...);



possono coesistere oppure non è necessario usarli entrambi?

Sì, possono coesistere e puoi usarli entrambi per l'accesso ai dati, anche se è un po' strano dato che sfruttano tecnologie diverse per fare la stessa cosa (ADO.NET da un lato e EFCore dall'altro). Infatti, dato che ormai nella tua applicazione hai una classe che deriva da DbContext, puoi sfruttare quella e abbandonare il BackEndContext. Se hai tempo di imparare ad usare Entity Framework Core, è la strada che ti consiglio di seguire.

ciao,
Moreno

Enjoy learning and just keep making

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.