Escolha uma Página
Como hospedar sua aplicação Asp.Net Core MVC (inclusive 2.2) fora do Azure

Como hospedar sua aplicação Asp.Net Core MVC (inclusive 2.2) fora do Azure

Desenvolvimento de Aplicações

Por menos de U$3/mês você pode ter sua aplicação ASP.NET Core MVC 2.2 rodando num provedor realmente especializado em ASP.NET, com direito a e-mail, banco de dados MS SQL e um infinidade de recursos.

Usando Visual Studio 2017 versão comunitária (grátis) , ou também a versão comunitária do Visual Studio 2019, também grátis,  você consegue instalar sua aplicação ASP.NET Core 2.2 MVC num provedor especializado e com alta velocidade – e com um custo muito baixo. Esqueça Godaddy, LOCAWEB, e mesmo Azure (que acaba custando uma tinta quanto mais você usa).

Depois de muito pesquisar e apanhar, acabei descobrindo o provedor SmarterASP.NET..Em menos de uma hora, estava com minha aplicação Core 2.2 rodando. Aqui vai um passo a passo com dicas importantes. Detalhe importante: se você duvidar, pode ter 60 dias de uso grátis!!! Ou seja, você pode comprovar tudo o que estou falando aqui sem gastar um único centavo. Se escolher um plano pago você pode usar qualquer cartão de crédito (ou pagar com PAY-PAL). Se não gostar eles devolvem seu dinheiro.

Passo 1 – Incrição

Vá em SmarterASP.NET. NÃO se preocupe, este é o único formulário em inglês. Todo seu painel pode ser usado em português.

Escolha o plano 60 dias grátis, se não quiser pagar nada agora, Em segundos você recebe um e-mail de confirmação, podendo já acessar e publicar sua aplicação CORE MVC.

A primeira grata surpresa: você ganha um domínio prontinho, seu, para testar sua aplicação na WEB (depois você aponta um domínio seu, não se preocupe agora).

Passo 2 – Acesso

Clique no link recebido por e-mail enviado pela SmarterASP.NET. . Você já pode acessar seu painel. Escilha Português se não quiser inglês. Ao acessar, se o sistema perguntar onde quer seu servidor (USA ou Europa), defina onde quer. Eu defini USA e roda rapisíssimo, fiquei impressionado! Você vai ter de cara um domínio tipo seunomedeusuario-001-site1.htempurl.com


Passo 3 – Pegue os dados de Deploy para seu Visual Studio

Você não vai precisar usar FTP. Vai subir sua aplicação via Visual Studio e comprovar que é rapidíssimo comparada a qualquer subida via FTP. Clique em Sites e depois em Mostrar Informações Web Deploy. Não se preocupe em copiar nada.

Clicando e Mostrar informações abre um painel abaixo:

Deixe VS Estado como ON (verde). Clique no botão “Se quiser publicar configuração”. Os lugares que risquei em amarelo vao ter seu nome de usuário.

Salve em seu disco local o arquivo Site1. Este é um arquivo com extensão .PubblishSettings, próprio para o Visual Studio. Seu conteúdo é este:

Passo 4 – Abra sua aplicação no Visual Studio e instale o arquivo para PublishSettings

Clique no Solution Explorer do Visual Studio, no lado direito, no nome do seu projeto (com o botão direito). Escolha a opção Publishing.


Clique em Create new profile:


Clique em Import Profile e dê OK


Escolha o Arquivo Site1 que foi gravado no seu disco local:

Clique no botão Publish. O Visual Studio iniciará a subida da sua aplicação, que você notará que é bem rápida.

Uma dica importante: na primeira vez, ANTES de clicar no botão PUBLISH NO VISUAL STUDIO, CLIQUE EM settings, que fica no lado direito do painel de publicação (as vez fica meio escondido na tela). Clique em VALIDAR CONEXÃO (validate connection). Se o sistema reclamar alguma coisa de certificado, diz que sim, que aceita o certificado e pronto. Clique em SALVAR (save) e agora sim, pode publicar.

As vezes o Visual Studio “esquece” que você já fez isso e começa a dar erro na publicação do site. É só repetir a operação acima e tudo volta ao normal. A partir da segunda vez que você publica a atualização é rapidíssima! É a vantagem desse provedor permitir WEB DEPLOY, que só atualiza os arquivos que efetivamente mudaram… Se for fazer pelo FTP do Visual Studio, que é burrinho, pode sair e voltar um bom tempo depois (pois ele sobe todos os arquivos de novo, sempre). É melhor – neste caso, publicar num diretório e subir com o Filezilla, parametrizando-o para só enviar arquivos com novas datas. Mas certamente você vai esquecer que existe FTP usando o WEBDEPLOY…

Outras vantagens:

Você pode criar um número ilimitado de bancos de dados, inclusive SQL. Não paga nada a mais por isso. Para as minhas aplicações isso é muito bom. O desempenho dos servidores é ótimo.

Se tiver algum problema:

  • O provedor tem uma base de conhecimento com uma série de bons artigos explicativos, agrupados por tópicos. Tem tudo ali que em geral os clientes podem ter dúvidas;
  • Escreva para o suporte. Testei e me responderam rapidinho (nem acreditei, estou acostumado com o padrão 24 horas da Locaweb). O suporte é mesmo 24 x 7! Basta abrir um tíquete de suporte na Central de Ajuda.

Obrigado pela sua leitura. Continue visitando este blog e compartilhe artigos em sua rede de relacionamento. Por favor, se quiser, registre sugestões e comentários ao final da página.

Usando SQL Storage Procedures no CORE MVC – parte 2

Usando SQL Storage Procedures no CORE MVC – parte 2

Desenvolvimento de Aplicações

Um dos problemas complicados no Core MVC é que não dá para usar as Views do SQL. Quando você tem de mostrar dados que tem diversas tabelas agrupadas, há algumas formas de contornar isso, usando procedures do SQL.

Se você vai operar com procedures, antes de tudo instale pelo Gerenciador do NuGet – se ainda não o tem instalado na sua aplicação, o Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Casos do método FromSql

Para executar procedures, use o método FromSql executa consultas RAW SQL. Mas existem algumas limitações para executar consultas RAW SQL ou procedures.

  • As consultas SQL só podem ser usadas para retornar tipos de entidades que fazem já parte do seu modelo. Portanto, não podem conter dados relacionados ou “montados” através de procedures. Existe uma forma de contornar isso, mas ninguém explica direito. Você deve montar um modelo “fake”, falso mesmo. Que não existe fisicamente no banco de dados. Depois de montar o modelo tem que fazer duas coisas:
    • incluir esse modelo “fake” no seu arquivo SuaAplicacaoContext.cs, dentro do diretório de modelos (Models);
    • o modelo tem que ter uma chave única (uniq key). No arquivo do modelo “fake” a chave da tabela combinada da procedure tem que ser precedida pelo comando [Key] (e para isso é preciso acrescentar a diretiva, no topo do arquivo de modelo, using System.ComponentModel.DataAnnotations). Aí, mesmo sem ser um arquivo físico ,a procedure ser comportará como se assim o fosse;
  • A consulta SQL sempre deve retornar dados para todas as propriedades da entidade. Então, basicamente, sua consulta SQL sempre vai ser algo como “Select * from {NomeDaTabela}” (sempre de uma única tabela dentre as que já estão mapeadas ou o da tabela “fake”).
    É até possível filtrar a tabela, usando parâmetros que funcionarão como uma cláusula “where”. Porém a procedure sempre irá retornar todos os campos da tabela (simples ou “fake”), retornando listas (claro que a procedure poderá trabalhar com outras tabelas, fazendo outras operações, mas o método FromSql sempre retornará uma lista do tipo “select * from Tabela” ou,em alguns casos, um valor único como “Select Count(*) from Tabela“. Você é quem decide: se o resultado é uma lista, injeta num .ToList(). Se o resultado é único, injeta num .SingleOrDefault();
  • Os nomes das colunas no conjunto de resultados sempre devem corresponder exatamente aos nomes das colunas às quais as propriedades são mapeadas (no modelo, ou Model, do contrário vai dar erro e s colunas que não batem virão com valores nulos).

Não há sentido em se usar o FromSql se não houver necessidade de filtrar a tabela com parâmetros ou necessidade de fazer operações acessórias dentro da procedure (atualizando outras tabelas). A procedure abaixo é praticamente inútil, no sentido de que poderia ser facilmente obtida sem nenhuma procedure:

CREATE PROCEDURE lista_todas_consultorias
AS
BEGIN
	SET NOCOUNT ON;
	SELECT * from consultorias
END
GO

Ela teria que usar, no controller, algo do tipo:

List<Consultorias> ListaDeConsultorias = _context.Consultorias.FromSql("lista_todas_consultorias").ToList;

Mas isso poderia ser obtido de várias outras formas, pois a tabela Consultorias já é mapeada, sendo possível obter a lista como no como por exemplo:

var ListagemDeConsultorias = await _context.Consultorias.ToListAsync();

Procedures simples com parâmetros usando FromSql

Já quando você que utilizar uma tabela já mapeada usando filtros (passando parâmetros), começa a fazer sentido usar o FromSql. Por exemplo, selecionar pessoas que estão ligadas a uma determinada Consultoria (considerando que as pessoas estão numa tabela já mapeada):

CREATE PROCEDURE seleciona_pessoas_duma_consultoria 
	@idConsultoria int
AS
BEGIN
	SET NOCOUNT ON;
	SELECT *  FROM dbo.ac_redepessoas
WHERE        (idConsultoria = @idConsultoria)
END
GO

Mesmo este uso, considerando que a tabela de pessoas já é mapeada e que contém o campo IdConsultoria, é bobinho. A instrução FromSql seria:

int idConsultoria = 1;
List<AcRedepessoas> ListagemDePessoasDaConsultoria = _context.AcRedepessoas.FromSql("seleciona_pessoas_duma_consultoria @p0", idConsultoria).ToList;

Mas isso também seria facilmente obtido diretamente no Core:

ListagemDePessoasDaConsultoria =  _context.AcRedepessoas.Where(x => x.IdConsultoria == idConsultoria).ToList();

Então, o uso de FromSql deve ocorrer em situações onde o Core MVC não pode, automaticamente, atualizar alguma tabela secundária ou fazer operações intermediárias. Também não se presta para operações do tipo Insert, Update e Delete.

Passando mais de um parâmetro

Algumas vezes você precisa passar mais de um parâmetro. O FromSql() tem um “overload”que aceita os parâmetros do objeto []. A primeira coisa a notar é o nome do parâmetro é “@p0”. Se houver mais parâmetros, incremente o contador como @p1, @p2 etc… O código seguinte mostra como passar vários parâmetros:

var ListagemDeConsultorias = await _context.Consultorias.ToListAsync();
int idConsultoria = 1;
var NomesDePessoas = "Roberto";
var ListagemDePessoasDaConsultoria = _context.AcRedepessoas
    .FromSql("ListaPessoasPorConsultoriaENome @p0, @p1",
    parameters: new[] { idConsultoria.ToString(), NomesDePessoas })
    .ToList();

Um cuidado: ao passar números inteiros, converta para string antes (se não vai dar erro no SQL). Existe também outra maneira de passar os parâmetros. Substitua @p0 por {0} (e se tiver mais parâmetros, @p1 por {1} e assim por diante.

int idConsultoria = 1;
var parametroConsultoria = new SqlParameter("@idDaConsultoria", idConsultoria);
List<acRedepessoas> ListaDePessoas = _context.acRedePessoas
            .FromSql("proc_lista_pessoas @idDaConsultoria", parametroConsultoria)
            .ToList();

Nesse formato, não é preciso antes converter o inteiro em “string“. Para passar 4 parâmetros, por exemplo:

var userType = _context.acRedepessoas.FromSql("dbo.AlgumaProcedure @Id = {0}, @Nome = {1}", 45, "Ada");

 

 

 

 

Para casos mais complexos, é preciso usar ExecuteSqlComand

Quando se trata de alterar um arquivo com procedure, este é comando que executa a procedure: ExecuteSqlComand, adequado para operações do tipo Insert, Update e Delete.

O que quase lugar nenhum explica é o seguinte: o comando ExecuteSqlComand não retorna listas. Retorna um inteiro. 0, se a operação foi bem sucedida. É só isso. Novamente: não há sentido em se usar esse comando a menos que você esteja atualizando outras tabelas intermediárias ou fazendo cálculos complexos antes de alterar ou inserir em registro.

A procedure a seguir insere um registro na tabela de Consultorias Categorias.

CREATE PROCEDURE usp_InsereConsultoria
 @NomeDaConsultoria nvarchar(300)
AS
BEGIN
    SET NOCOUNT ON;
    Insert into Consultorias Values (@NomeDaConsultoria)
END
GO

ExecuteSqlCommand deve ser usado em context.Database (na minha aplicação de exemplo _context = contexto;). Você pode usá-lo da seguinte maneira.

var NomeConsultoria= "José Consultores e Associados";
_context.Database
           .ExecuteSqlCommand("usp_InsereConsultoria @p0", NomeConsultoria);

É possível rodar o ExecuteSqlCommand no modo assíncrono também, como por exemplo:

await _context.Database.ExecuteSqlCommandAsync("usp_CriaConsultoria @p0, @p1", 
        parameters: new[] { "Nome Completo da Consultoria", "Nome de Guerra" });

 

A procedures mostradas anteriormente são muito simples. O problema é quando ser quer manusear resultados de diversas tabelas, amarrando umas às outras (joining).

O exemplo seguinte é baseado em uma aplicação que é essencialmente um questionário de avaliação de uma pessoa (qe se avalia e é avaliada por terceiros).

Ocorre que um questionário é sempre cadastrado por uma consultoria (e uma consultoria pode ter diversos questionários cadastrados). Quando ela quer aplicar o questionário para uma pessoa que vai ser avaliada, o sistema gera formulários de resposta para o avaliado e para todos avaliadores do avaliado. Quando qualquer uma das pessoas entra no sistema, ela acessa o questionário específico que deve responder. Nesta aplicação as respostas tem uma régua com todas alternativas (amarrada também ao modelo do questionário).

Ao acessar o formulário de respostas, o respondente tem de ler cada pergunta de cada questionário e salvar sua resposta. Há portanto uma tabela de respostas que guarda a NOTA dada (poderia ser uma resposta em texto). Essa tabela, no entanto, está amarrada:

  • a uma tabela de Avaliações, que tem a lista de todas avaliações do sistema, identificando o avaliador e o avaliado;
  • que por sua vez está amarrada a uma tabela de pessoas, que tem todos os participantes do sistema, de onde é pego o nome do Avaliado;
  • que por sua vez está amarrada a uma tabela de Consultorias, pois cada participante pertence a apenas uma Consultoria (e aqui pego o nome da Consultoria.

A tabela de Respostas também está amarrada:

  • A uma tabela que contém o texto das perguntas;
  • que por sua vez está amarrada a uma tabela que contém as competências a que cada pergunta pertence (com seu título e descrição);
  • que está amarrada a uma tabela de questionários modelos,
  • que está amarrada a uma tabela de tipos de questionários,
  • que finalmente está amarrada a um tipo de régua específico para cada questionário.

O modelo visual em SQL é o seguinte:

Construindo um modelo (model)

A primeira coisa a fazer é constrir um modelo que contenha todos os dados que serão usados, extraídos de todas fabelas acima. No caso. o fromulárioViewModel.cs:

namespace Coaching.Models.FormularioViewModels
{
    public class FormularioViewModel
    {
        public int IdRespostaAvaliacao { get; set; }
        public int? IdAvaliacao { get; set; }
        public int? IdPerguntaBanco { get; set; }
        public double? Nota { get; set; }
        public int IdAvaliado { get; internal set; }
        public int IdAvaliador { get; internal set; }
        public string TipoDeAvaliador { get; internal set; }
        public string NomeDoAvaliado { get; internal set; }
        public string NomeConsultoriaMenu { get; internal set; }
        public int? IdTipoQuestionario;
        public string TituloCompetencia;
        public string DescCompetencia;
        public string TituloCompetenciaLimpo;
        public string DescCompetenciaLimpo;
        public string OrientadoPara;
        public string NomeQuestionario;
        public int? IdConsultoria;
        public string NomeRegua;
        public int IdRegua;
        public int IdCompetenciaBanco;
        public int? OrdemPergunta;
        public string AssertivaAuto;
        public string AssertivaGeral;

       
    }
}

Esse modelo tem tudo que é necessário para selecionar e para mostrar uma única pergunta e sua resposta.

Preparando o Controller

Usando Linq, somente para pegar a lista de possíveis respostas de uma única avaliação, olha o tamanho do Join necessário:

var listarespostas = await (from a in _context.QuestionarioTipos
                                        join b in _context.QuestionariosModelos on a.IdTipoQuestionario equals b.IdTipoQuestionario
                                        join c in _context.PerguntasBancoGeral on b.IdPerguntaBanco equals c.IdPerguntaBanco
                                        join d in _context.CompetenciasBancoGeral on c.IdCompetenciaBanco equals d.IdCompetenciaBanco
                                        join e in _context.Reguas on a.IdRegua equals e.IdRegua
                                        join f in _context.AvaliacoesRespostas on c.IdPerguntaBanco equals f.IdPerguntaBanco
                                        join g in _context.Avaliacoes on f.IdAvaliacao equals g.IdAvaliacao
                                        join h in _context.AcRedepessoas on g.IdAvaliado equals h.IdUsuario
                                        join i in _context.Consultorias on h.IdConsultoria equals i.IdConsultoria
                                        where g.IdAvaliacao == id
                                        select new Models.FormularioViewModels.FormularioViewModel
                                        {
                                            NomeConsultoriaMenu = i.NomeConsultoriaMenu,
                                            NomeDoAvaliado = h.Nome,
                                            TipoDeAvaliador = g.TipoDeAvaliador,
                                            IdAvaliador = g.IdAvaliador,
                                            IdAvaliado = g.IdAvaliado,
                                            AssertivaAuto = c.Assertivaauto,
                                            AssertivaGeral = c.Assertivageral,
                                            OrdemPergunta = b.OrdemPergunta,
                                            IdCompetenciaBanco = d.IdCompetenciaBanco,
                                            IdRegua = e.IdRegua,
                                            NomeRegua = e.NomeRegua,
                                            IdConsultoria = a.IdConsultoria,
                                            NomeQuestionario = a.NomeQuestionário,
                                            OrientadoPara = a.OrientadoPara,
                                            DescCompetenciaLimpo = d.DescCompetenciaLimpo,
                                            TituloCompetenciaLimpo = d.TituloCompetenciaLimpo,
                                            DescCompetencia = d.DescCompetencia,
                                            TituloCompetencia = d.TituloCompetencia,
                                            IdTipoQuestionario = b.IdTipoQuestionario,
                                            IdAvaliacao = f.IdAvaliacao,
                                            IdPerguntaBanco = f.IdPerguntaBanco,
                                            IdRespostaAvaliacao = f.IdRespostaAvaliacao,
                                            Nota = f.Nota
                                        })
                                        .OrderBy(b => b.OrdemPergunta)
                                        .OrderBy(c => c.IdPerguntaBanco)
                                        .ToListAsync();

Para usar uma procedure equivalente ao modelo, é preciso gerá-la no servidor (pode ser via o próprio Visual Studio, mas é melhor usar o seu Microsoft Managment SQL Studio. O VS, mesmo 2017, é lento demais):

CREATE PROCEDURE visualiza_lista_respostas 
	-- Add the parameters for the stored procedure here
	@idQuestionario int 

AS
BEGIN
	-- SET NOCOUNT ON added to prevent extra result sets from
	-- interfering with SELECT statements.
	SET NOCOUNT ON;

    -- Insert statements for procedure here
	SELECT dbo.questionario_tipos.idTipoQuestionario AS IdTipoQuestionario, dbo.competencias_banco_geral.tituloCompetencia AS TituloCompetencia, dbo.competencias_banco_geral.descCompetencia AS DescCompetencia, 
             dbo.competencias_banco_geral.tituloCompetenciaLimpo AS TituloCompetenciaLimpo, dbo.competencias_banco_geral.descCompetenciaLimpo AS DescCompetenciaLimpo, dbo.questionario_tipos.orientadoPara AS OrientadoPara, 
             dbo.questionario_tipos.NomeQuestionário AS NomeQuestionario, dbo.questionario_tipos.idConsultoria AS IdConsultoria, dbo.reguas.NomeRegua, dbo.questionario_tipos.idRegua AS IdRegua, dbo.competencias_banco_geral.idCompetenciaBanco AS IdCompetenciaBanco, 
             dbo.questionarios_modelos.OrdemPergunta, dbo.avaliacoes_respostas.idRespostaAvaliacao AS IdRespostaAvaliacao, dbo.avaliacoes_respostas.idAvaliacao AS IdAvaliacao, dbo.avaliacoes_respostas.idPerguntaBanco AS IdPerguntaBanco, 
             dbo.avaliacoes_respostas.nota AS Nota, dbo.perguntas_banco_geral.assertivageral AS AssertivaGeral, dbo.avaliacoes.idAvaliado AS IdAvaliado, dbo.avaliacoes.idAvaliador AS IdAvaliador, dbo.avaliacoes.tipoDeAvaliador AS TipoDeAvaliador, 
             dbo.avaliacoes.idTipoquestionario AS idTipoQuestionario, dbo.ac_redepessoas.Nome AS NomeDoAvaliado, dbo.consultorias.nomeConsultoria AS NomeConsultoriaMenu, dbo.perguntas_banco_geral.assertivaauto AS AssertivaAuto
FROM   dbo.questionario_tipos INNER JOIN
             dbo.questionarios_modelos ON dbo.questionario_tipos.idTipoQuestionario = dbo.questionarios_modelos.idTipoQuestionario INNER JOIN
             dbo.perguntas_banco_geral ON dbo.questionarios_modelos.idPerguntaBanco = dbo.perguntas_banco_geral.idPerguntaBanco INNER JOIN
             dbo.competencias_banco_geral ON dbo.perguntas_banco_geral.idCompetenciaBanco = dbo.competencias_banco_geral.idCompetenciaBanco INNER JOIN
             dbo.reguas ON dbo.questionario_tipos.idRegua = dbo.reguas.idRegua INNER JOIN
             dbo.avaliacoes_respostas ON dbo.perguntas_banco_geral.idPerguntaBanco = dbo.avaliacoes_respostas.idPerguntaBanco INNER JOIN
             dbo.avaliacoes ON dbo.avaliacoes_respostas.idAvaliacao = dbo.avaliacoes.idAvaliacao INNER JOIN
             dbo.ac_redepessoas ON dbo.avaliacoes.idAvaliado = dbo.ac_redepessoas.idUsuario INNER JOIN
             dbo.consultorias ON dbo.ac_redepessoas.idConsultoria = dbo.consultorias.idConsultoria
WHERE (dbo.avaliacoes_respostas.idAvaliacao = @idQuestionario)
ORDER BY dbo.questionarios_modelos.OrdemPergunta, IdPerguntaBanco
END
GO

Para testar a procedure no servidor, usamos nosso conhecido comando execute (no exemplo abaixo, pegando todas respostas da avaliação número 40):

execute visualiza_lista_respostas 40
-- ou, se só quiser pegar um valor de retorno (0 no caso de sucesso)
DECLARE @return_value intDECLARE @return_value int
EXEC @return_value = [dbo].[visualiza_lista_respostas] @idQuestionario = 40
SELECT 'Return Value' = @return_value
GO

Rodando o execute no Servidor SQL, temos (visão parcial de um formulário selecionado):

Para rodar num controller do MVC, será preciso usar o comando ExecuteSqlCommand . 

No entanto, precisamos ter ao meno uma view (visualizador). Usando o scafolding, vamos gerar uma view simples sobre o modelo já implementado, Daremos a esta primeira ação da view o nome respondente_formulario

 

Obrigado pela sua leitura. Continue visitando este blog e compartilhe artigos em sua rede de relacionamento. Por favor, se quiser, registre sugestões e comentários ao final da página.

Populando Papéis (roles),usuários principais (admin,managers) e menus por papel a partir do Startup.cs do Core MVC

Populando Papéis (roles),usuários principais (admin,managers) e menus por papel a partir do Startup.cs do Core MVC

Desenvolvimento de Aplicações

 Muitas vezes você quer pré-definir os papéis (roles) para todos possíveis usuários da sua aplicação, Bem como definir um ou mais usuários com poder administrativo geral, ou também um usuário gerenciador, com menos poderes que o administrador. Este artigo mostra como fazer isso,

Ao rodar o arquivo STARTUP.CS é perfeitamente possível gerar todos os papéis (Roles( desejados para a sua aplicação, bem como definir ao menos um usuário administrativo com superpoderes e outros usuários com menores poderes. Isso vai ajudar, depois, a definir menus seletivos, onde só aparecem opções de navegação a que cada papel (role) dá direito.

Passo 1 – Nova tabela no banco de dados

Parimos do princípio que você já tem seu database com as tabelas que necessita, conforma artigos anteriores, O que vamos precisar agora é de uma nova tabela que contenha o que o menu de cada pape (role( deve conter ou não.. Ou seja, precisamos fazer uma tabela de relacionamento entre a tabela ASP.NET Roles e nossa tabela de menu. Vamos ver em detalhes sobre como criar nossa nova Tabela de Menus que tem um relacionamento com a tabela ASP.NET Identity AspNetRoles. A ess tabela vamos dar o nome MenuMaster, com os seguintes campos:

 

Tabela MenuMaster – Campos e Descrições

MenuIdentity é o campo de identidade usado como linha de ID (KEY)
MenuID é a identidade propriamente dita usada como referência primárias para qualquer campo do Menu
Parente_MenuID para cada top  MenuID será usado o valor “*”. Esse valor serpa usado somente para itens de menu com nível igual a 1 (primeira opção por default). Se na hierarquia de menus houver níveis 2 ou 3, elas farão referência ao menu raiz *MenuID”, que são pais
User_Rool Cria o menu para cada papel de usuário (User Role). O menu serpa mostrado para os usuários que tem esse papel (role) e que estiverem logados. Por exemplo, Admin pode criar diferentes menus para gerentes, consultores e outros papéis, E somente usuários que tenham esses papéis poderão ver esses menus
MenuFileName Este é o nome real para cada opção do menu (o que aparece em tela).  A ideia qui é usar o view nMWdo MV como MenuFileName
MenuURL É o Menu path para cada item do Menu, usado como hiperlink,, Em MVCé o nome do Controlador (controller)
USE_YN Se usado Y, o item de menu vai aparecer, Se usado N, não vai aparecer,  mesmo que ateda os requisitos de papel(role), Em geral é controlado por Viewbags, que definem se em certas condições do item de menu deve ou não aparecer,
CreateDate Data de criação do item do Menu

Passo 2- Criando a tabela no banco de dados, antes de popula-la

No arquivo STARTUP.CS, acrescente em services,addIdentity a parte de código relativo a

//Seting the Account Login page
            services.ConfigureApplicationCookie(options =>
Se ao compilar o Visual Stdio reclamar que não consegue apagar um diretório na pasta OBJ da aplicação, apague manualmente e recompile novamente,

Agora vamos criar o modelo com a classe MenuMaster, na pasta Models:

Passo 3 – Gerando a tabela MASTERMENU no nosso database

Recompile a aplicação para ver se até aqui não deu qualquer erro. O resultado deve ser:

========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

No Solution Explorer clique na pasta Controllers e com o botão da direita selecione ADD->New Scaffolded Item. Escolha MVC e à direita escolha MVC Controllers with Views, using Entity Framework. Clique no botão ADD.

Em Model Class escolher  o modelo MenuMaster , que ai aparecer como MenuMaster (DiagnosticoCultura.Models) . Clique no botão ADD.

Agora vamos Rodar a miração na console PMC:

add-migration mastermenu

e depois

update-database

Se compilar o programa e digitar https://localhost:44387/MenuMasters você verá que está tudo pronto para cadastrar os menus.

Passo 4 – Criando classes de interface

Agora é hora de criarmos uma interface com um método chamado GetMenuMaster() e outro método chamado GetMenuMaster (String UserRole).

Implementaremos essa interface em nosso serviço para obter todos os detalhes do menu da tabela e também outro método para obter o menu considerando o papel (ROLE) do usuário.

Para criar a interface, adicione uma nova classe à sua pasta de modelos e nomeie a classe como “IMenuMasterService”. Vamos mudar a classe para uma interface, pois vamos criar uma interface para implementar em nosso serviço

Passo 5: Criação do Serviço de Menus:

Agora vamos adicionar uma nova pasta de serviços de classe (abrir uma pasta raiz chamada Services) e nomear a classe como “MenuMasterService“.

Nesta classe, estaremos implementando nossa interface IMenuMasterService.

Sabemos que, se implementarmos a interface, devemos declarar o método de interface em nossa classe. Neste serviço, usamos o método de interface e retornamos a lista com detalhes do Menu e também retornamos os detalhes do Menu por função do usuário. Depois estaremos injetando isso diretamente em nossa página de visualização.

Passo 6: Registrando o serviço

Precisamos registrar nosso serviço criado no contêiner. Abra o Startup.cs do seu projeto para adicionar o serviço ao contêiner.

Na classe Startup.cs, encontre o método denominado ConfigureServices e adicione seu serviço “MenuMasterService” como abaixo.

Passo 7: Injetando o serviço de menus na página _Layout.cshtml

Agora, é muito mais simples e fácil, já que podemos injetar diretamente o serviço em nossa página de visualização e vincular todo o resultado à nossa página de visualização.

Para injetar o Serviço em nossa Visualização, aqui estaremos usando nossa página _Layout.cshtml existente.

Como vamos exibir o menu no topo do nosso site e usá-lo em todas as nossas páginas, aqui usamos a página _Layout.cshtml para vincular os resultados do menu como um menu baseado no usuário logado.

Aqui primeiro verificamos se o usuário está Autenticado em nosso site. Se o usuário estiver logado, obteremos os detalhes do papel do usuário conectado e vincularemos o menu com base nas funções do usuário.

Aqui no exemplo estamos vinculando 2 nível do menu como Menu Principal e Submenu.

Em nosso resultado de tabela, verificamos todos os Parenut_MenuID = ”*”, já que estaremos exibindo o menu principal com o parent_MenuID como “*” e no próximo loop interno, exibimos o submenu apropriado para o menu principal.

IMPORTANTE> Faça um backup do _Layout.cshtml ANTES de alterar qualquer coisa, Se 

Obrigado pela sua leitura. Continue visitando este blog e compartilhe artigos em sua rede de relacionamento. Por favor, se quiser, registre sugestões e comentários ao final da página.

Ajustando os parâmetros de senha no CORE MVC

Ajustando os parâmetros de senha no CORE MVC

Desenvolvimento de Aplicações

 Se você define usar o módulo de Autenticação / Identidade, saiba que pode definir com clareza todos os parâmetros para sua aplicação

Você pode definir todos os padrões no arquivo STARTUP.CS. Por padrão, Identity requer que as senhas contenham um caractere maiúsculo, caractere minúsculo, um dígito e um caractere não alfanumérico. As senhas devem ter pelo menos seis caracteres. PasswordOptions pode ser definido em Startup.ConfigureServices.

IdentityOptions.Password especifica o PasswordOptions com as propriedades mostradas na tabela. 

Propriedade Descrição Padrão
RequireDigit Requer um número entre 0-9 na senha true
RequiredLength O comprimento mínimo da senha 6
RequireLowercase Requer um caractere minúsculo na senha true
RequireNonAlphanumeric Requer um caractere não alfanumérico na senha. true
RequiredUniqueChars Aplica-se somente ao ASP.NET Core 2.0 ou posterior. Requer o número de caracteres distintos na senha 1
RequireUppercase Requer um caractere maiúsculo na senha true

 

Obrigado pela sua leitura. Continue visitando este blog e compartilhe artigos em sua rede de relacionamento. Por favor, se quiser, registre sugestões e comentários ao final da página.

Modificando e ampliando o Gerenciamento de Identidades do ASP.NET Core 2.2 e implementar Componentes Synfusion

Modificando e ampliando o Gerenciamento de Identidades do ASP.NET Core 2.2 e implementar Componentes Synfusion

 Vimos no artigo “Como instalar Identidade e Autorização da Microsoft criar um projeto novo com o Syncfusion“, com todos componentes que deseja usar –  e depois como acrescentar Autenticação e Identidade da Microsoft.

Neste artigo veremos como modificar e ampliar o arquivo de “usuários” (“AspNetUsers”) – personalizando-o para ter mais campos e também para usar uma identidade (ID) que seja numérica – e não string.

Passo 1: Instale a sua aplicação Core MVC 2.2

Estou Assumindo que você já tenha um aplicativo da Web com a autenticação do usuário ativada, montada pelo próprio template do Visual Studio 2017 ou 2019. Na geração da aplicação você pode configurá-lo selecionando “Contas de usuário individuais” como o tipo de autenticação ao criar seu projeto.

Ou você pode adicioná-lo manualmente a um aplicativo seguindo as instruções do artigo:

Como instalar Identidade e Autorização da Microsoft criar um projeto novo com o Syncfusion

 

Passo 2: O que pode ser alterado no arquivo de Identidade?

Há duas coisas que não gosto quando a Microsoft instala seu Microsoft Identity Manager – mas devo reconhecer que essa funcionalidade torna realmente fácil adicionar usuários ao seu site ASP.NET Core.

Há sempre duas coisas que quero sempre mudar imediatamente.

A primeira é pedir o nome de um usuário (para inclusive poder usá-lo depois na barra de navegação com um “Olá NOME DE USUÁRIO” (no lugar de “Ola EMAIL DO USUÁRIO”. A segunda é alterar aquela detestável chave primária do usuário em “string”, substituindo-a por valores “inteiros”. – tornando muito mais fácil integrar a tabela de usuários (“ASPNETUSERS”) com as demais tabelas da aplicação. Nos próximos passos deste artigo vamos ver como fazer isso.

No exemplo, ao registra um usuário vou perguntar seu NOME COMPLETO. Na sua implementação você pode optar por perguntar separadamente o nome e sobrenome (e criar, no modelo, um campo só de leitura que junta o nome com o sobrenome, criando o nome completo automaticamente (a vantagem de fazer isso é que a pessoa é sempre obrigada a digitar os 2 campos… Quando você pede somente o nome completo, ela pode desconsiderar e digitar somente o primeiro nome).

Você pode acrescentar quantos campos quiser no padrão de gerenciamento de identidade padrão da Microsoft, que por default utiliza apenas de endereços de e-mail.

Finalmente, como já falei,  gosto de mudar a chave primária de uma string para um inteiro para corresponder ao resto do meu modelo de dados. Costumo preferir números inteiros em GUIDs, e não strings, difíceis de conferir. O pressuposto aqui é que você já tenha um aplicativo da Web com a autenticação do usuário ativada. Ao criá-lo, você pode configurá-lo selecionando Contas de usuário individuais como sendo o tipo de autenticação do projeto. Ou você pode adicioná-lo manualmente a um aplicativo seguindo nossas instruções no artigo do Passo 1.

 

Passo 3: Adicionando novos modelos para Autorização / Identidade

Vamos começar adicionando dois novos modelos ao nosso aplicativo. Nas suas pastas Modelos (Models), crie uma nova classe chamada AppRole que estende o IdentityRole. Isso pode ser usado para atribuir funções especiais a usuários como “admin” e outras categorias de usuários, com papéis diferentes na sua aplicação.

Em seguida, adicione uma classe AppUser que amplia o IdentityUser para que possamos coletar mais dados sobre eles (você pode acrescentar mais campos se quiser). Note que o nome completo é montado a partir de nome sobrenome, neste exemplo.

Note que as duas classes são marcadas com <int>.

Isso informa ao Gerenciamento de Identidades que queremos usar chaves primárias baseadas em números inteiros.

O AppUser marca suas propriedades com algumas anotações de dados padrão para tornar o primeiro e o último nome necessários com um comprimento máximo de 20 caracteres. Essas propriedades também são marcadas com PersonalData, ficando disponíveis automaticamente para download e exclusão.

Tornar os dados capazes de serem baixados e excluídos ajuda a atender aos requisitos GDPR. Também foi uma propriedade FullName para formatar de forma consistente o nome completo de um usuário em todo o aplicativo.

Passo 4 – Preparando o banco de dados

Muito provavelmente sua aplicação vai rodar em um servidor externo MYSQL ou MSSQL.

Crie o database em vazio (sem tabelas ainda) e pegue a definição da string de conexão. Exemplo:

“Data Source=EndereçoDoServidor;Initial Catalog=NomeDOBancoDeDados;User Id=NomeDoUsuario;Password=SenhaDoUsuario;”

No arquivo appsetings,json TROQUE a string de conexão gerada na criação do seu aplicativo pela sua string de conexão.

Passo 5 – Atualizando o Context Database (diretório Data, arquivo ApplicationDbContext.cs

O contexto do banco de dados estende IdentityDbContext, precisamos atualizá-lo para informá-lo sobre nossas novas classes e estratégia de chave primária.

 

Nós também queremos adicionar ou atualizar OnModelCreating para ignorar a propriedade FullName que adicionamos. É uma propriedade computada que não queremos armazenar no banco de dados.

Nossa classe de inicialização está fazendo referência à identidade padrão. Precisamos atualizá-lo para nossa identidade personalizada. Antes, no arquivo startup.cs:

Depois:

Passo 6 – Atualizando _loginPartial.cshtml

O controle de login na barra de ferramentas também possui referências que precisam ser atualizadas. (Não se esqueça de adicionar uma declaração usando à sua pasta de modelos aqui.)

 

Lembre-se não vamos mais mostrar ao usuário seu endereço de e-mail. Em vez disso, vamos mostrar seu nome.

Antes:

Depois:

Possível Problema com caracteres alienígenas

Se a linha do navegador apresentar caracteres internacionais com símbolos alienígena, é porque o Visual Studio salvou o arquivo _loginPartial.cshtml em ANSI – e não em UTF-8.

O artigo aqui explica isso. Abra o arquivo _loginPartial.cshtml  com o notepad++  (instale esse editor gratuito que é fantástico, dá de 100 a 0 no notepad da Microsoft). Salve o arquivo com ENCODING UTF-8 e rode a aplicação para ver como “sumiram os caracteres alienígenas”.

 

Passo 7 – Substituir páginas de identidade padrão (Default Identity Pages)

  1. Clique com o botão direito no nome do projeto.
  2. Selecione ADD> New Scaffolded Item.
  3. Selecione Identity (Identidade) no menu à esquerda.
  4. Selecione ADD.
  5. Escolha Account/Manage/Index e também a opção Account/Register.
  6. Selecione sua classe de contexto do banco de dados existente.

Isso criará novas páginas para o registro do usuário e a página do perfil do usuário, onde podemos solicitar o primeiro e o último nome.
Nota> se quiser usar o primeiro nome, o ultimo no ou ainda o nome completo, em outras páginas, escolha essas páginas já no item 5, acima,

 

Passo 8 – Arquivo _ValidationScriptsPartial.cshtml

Copie o HTML do seu arquivo atual, localizado na pasta Pages/Shared, para o novo na pasta Areas/Identity/Pages, para ter certeza de que são os mesmos.

 

Passo 9 – Arquivo Register.cshtml.cs

Adicione propriedades de primeiro e último nome à classe InputModel. Se não encontrar o arquivo, é porque se esqueceu de fazer o ADD NEW SCAFFOLDED do passo 7. Este arquivo Fica na pasta Areas;Identity/Pages/Account e dentro de Register.cshtml

 

Adicione esses valores de propriedade à declaração de variável do usuário em OnPostAsync

Passo 10 – Arquivo Register.cshtml

Adicione os campos de entrada para primeiro e último nome, logo abaixo do controle asp-validation-summary.

 

Passo 11 – Arquivo Index.cshtml.cs

Esta é uma classe de fica no folder Areas/Identity/Pages/Account/Manage

Adicione novamente as propriedade first e last name na classe InputModel.

Atualize a variável Input e OnGetAsync para popular essas propriedades.

Salve as propriedades em OnPostAsync que fica próxima ao final do método.

Passo 12 – Arquivo Index.cshtml

Adicione os campos de entrada para nome e sobrenome abaixo da entrada de e-mail e acima do número de telefone.

Passo 13 – Atualizando Migrações (Update Migrations)

O próximo passo lógico é atualizar migrações, para criar no banco de dados todas as tabelas de autorização e de identidade (ji usando números inteiros para o ID de pessoas (Users) e regras (Roles). 

Se o seu banco de dados está criado mas está vazio (sem tabelas)

Neste caso minha primeira recomendação é criar um template do seu projeto, para que você possa iniciar novas aplicações já a partir do estágio atingido no passo 12. Para criar o template:

  1. No menu superior dê um BUILD na solução para ter certeza de que não há nenhum erro ou file,
  2. Salve os arquivos todos.
  3. No menu superior, em Project, escolha Export Template. Deixe marcado Export Template e dê um NEXT. e um nome e uma descriçao para o seu temlate, que vai aparecer cada vez que você iniciar um novo projeto

Se eu banco de dados está criado, mas não está vazio (tem tabelas)

Isso significa que você já fez pelo menos alguma migração neste projeto. Se você tentar adicionar uma nova migração, ela falhará devido à alteração da chave primária.

Neste caso, o caminho mais fácil é:

  1. Excluir sua pasta de migração
  2. Excluir seu banco de dados ou recriá-lo (não esqueça de mudar a string de conexão em APPSETTINGS.
  3. Se você não quiser recriar o banco de dados, mas somente limpá-lo completamente, deixando-o sem tabelas, views e procedures, rode no sue MSSQL a rotina proposta abaixo. Abra uma janela de NEW QUERY, copie a rotina e execute.
  4. Depois de recriar ou limpar o banco de dados, você poderá adicionar sua “primeira migração”.
  5. No Console do Gerenciador de Pacotes PMC rode estes dois comandos, um após o outro:
    1. Add-Migration Initial -o Data\Migrations
    2. Update-Database

Agora execute seu aplicativo e você poderá registrar uma conta com nome e sobrenome, ver o nome do usuário na barra de navegação e atualizar o primeiro e último nome. Agora você pode usar a propriedade AppUser.Id em seus próprios modelos para referenciar o registro do usuário como faria com qualquer outro modelo.

 

Rodando o script acima, ele vai mostrar que apagou os índices e as tabelas:

Dropped FK Constraint: FK_AspNetRoleClaims_AspNetRoles_RoleId on AspNetRoleClaims
Dropped FK Constraint: FK_AspNetUserClaims_AspNetUsers_UserId on AspNetUserClaims
Dropped FK Constraint: FK_AspNetUserLogins_AspNetUsers_UserId on AspNetUserLogins
Dropped FK Constraint: FK_AspNetUserRoles_AspNetRoles_RoleId on AspNetUserRoles
Dropped FK Constraint: FK_AspNetUserRoles_AspNetUsers_UserId on AspNetUserRoles
Dropped FK Constraint: FK_AspNetUserTokens_AspNetUsers_UserId on AspNetUserTokens
Dropped PK Constraint: PK___EFMigrationsHistory on __EFMigrationsHistory
Dropped PK Constraint: PK_AspNetRoleClaims on AspNetRoleClaims
Dropped PK Constraint: PK_AspNetRoles on AspNetRoles
Dropped PK Constraint: PK_AspNetUserClaims on AspNetUserClaims
Dropped PK Constraint: PK_AspNetUserLogins on AspNetUserLogins
Dropped PK Constraint: PK_AspNetUserRoles on AspNetUserRoles
Dropped PK Constraint: PK_AspNetUsers on AspNetUsers
Dropped PK Constraint: PK_AspNetUserTokens on AspNetUserTokens
Dropped Table: __EFMigrationsHistory
Dropped Table: AspNetRoleClaims
Dropped Table: AspNetRoles
Dropped Table: AspNetUserClaims
Dropped Table: AspNetUserLogins
Dropped Table: AspNetUserRoles
Dropped Table: AspNetUsers
Dropped Table: AspNetUserTokens

Note, abaixo, que as tabelas foram geradas dom IDs com números inteiros!!!

Rodando a aplicação, a tela de entrada contendo à direita os campos de Login e Registro

Tela de Registro, com Nome e Sobrenome:

Tela Inicial, mostrando o nome no lugar do e-mail. E aparece o campo de Logout, no lugar de login.

Instalando o Syncfusion

Instalando os pacotes via NuGet Packages

O NuGet Package Manager pode ser usado para pesquisar e instalar pacotes do NuGet na solução ou no projeto do Visual Studio.

Passo 1 : Clique com o botão direito do mouse no projeto / solução na guia Solution Explorer e escolha Manage NuGet Packages…

 

Alternativamente, clique Tools, menu, NuGet Package Manager | Manage NuGet Packages for Solution…

Passo 2 : Selecione o NuGet.org na lista suspensa Fonte do pacote (Package source drop-down).

Passo 3 : Todos os Pacotes do Syncfusion NuGet estão listados e disponíveis. Pesquise e instale os pacotes necessários em seu aplicativo clicando no botão Instalar..

Os pacotes Syncfusion NuGet estão disponíveis publicamente em NuGet.org desde a versão v16.2.0.46 . Para instalar versões anteriores à 16.2.0.46 , configure Syncfusion URL fees privado.

Em nosso exemplo vamos instalar a versão CORE J2 17.2.0.34.

Os controles do ASP.NET Core UI são criados do zero para serem leves, responsivos, modulares e sensíveis ao toque. Inclui mais de 50 componentes, incluindo grade, gráfico, agendador e muito mais. Saiba mais: https://www.syncfusion.com/aspnet-core-ui-controls Características principais:

  • Suporta o TagHelper e o construtor fluente para inicialização de controle.
  • Suporte de anotação de dados.
  • Temas internos impressionantes, incluindo material, bootstrap, tecido, etc.
  • Conformidade com os padrões de acessibilidade – WCAG 2.0 e Seção 508.

Componentes e controles disponíveis:

GRIDS
DataGrid
Pivot Table
Tree Grid (Preview)
DATA VISUALIZATION
Charts
Stock Chart (Preview)
Circular Gauge
Diagram
Heatmap chart
Linear Gauge
Maps
Range Selector
Smith Chart
Sparkline Charts
TreeMap
EDITORS
Rich Text Editor
Word Processor
Chips (Preview)
CALENDARS
Scheduler
Calendar
DatePicker
DateRangePicker
DateTime Picker
TimePicker
BUTTONS
Button
ButtonGroup
Dropdown Menu
Progress Button
Split Button
DROPDOWNS
AutoComplete
ComboBox
Dropdown List
MultiSelect Dropdown
NAVIGATION
Accordion
Context Menu
Menu Bar
Sidebar
Tabs
Toolbar
TreeView
INPUTS
Form Validator
TextBox
Input Mask
Numeric Textbox
Radio Button
Checkbox
Color Picker
File Upload
Range Slider
Toggle Switch Button
LAYOUT
Avatar
Card
Dialog
ListView
Tooltip
Splitter (Preview)
NOTIFICATIONS
Badge
Toast
FORMS
In-place Editor (Preview)
Viewer
PdfViewer (Preview)

Passo 4: Ajustes Finais

Visual Studio 2017/2019

Abra o arquivo ~/Views/_ViewImports.cshtml e importe o pacote Syncfusion.EJ2. Acrescente:

@addTagHelper *, Syncfusion.EJ2

Adicione os recursos do lado do cliente por meio do CDN ou do pacote npm local no elemento <head> da página de layout ~/Views/Shared/_Layout.cshtml. Acrescente:

Adicione o Essential JS 2 Script Manager no final do elemento <body> na página de layout ~/Views/Shared/_Layout.cshtml.

Agora, adicione os componentes do Syncfusion Essential JS 2 em qualquer página da web (cshtml) na pasta Views.

Por exemplo, o componente de calendário é adicionado na página ~/Views /Home/Index.cshtml.

Execute o aplicativo. O componente de calendário do Essential JS 2 será renderizado no navegador da web.

Conclusão

Agora você pode salvar o template do projeto considerando o uso dos componentes e controles do Syncfusion. Basta ir in Projec->Export Template. Ao iniciar um novo projeto, poderá desfrutar de inicio de todas as mudanças. Eventualmente, terá de mudar a conexão ao banco de dados (em appsettings), apagar o diretórios migrations e fazer a primeira migração novamente. Mas isso é coisa que tomará ,initos – e não horas. Esperamos que tenha curtido este artigo e – se tiver sugestões ou dúvidas – é só nos enviar,

Ajustando os parâmetros de senha no CORE MVC

Syncfusion Core: como instalar Identidade e Autorização da Microsoft

 Antigamente, ao definir um projeto novo em core MVC, você tinha que definir se o projeto teria ou não identificação/autorização. A partir do core 2.1 isso não é mais necessário. Você pode definir isso depois. Melhor ainda: você pode criar um projeto novo com o Syncfusion, com todos componentes que deseja usar –  e depois acrescentar Autenticação e Identidade da Microsoft

Passo 1: Instale o Gerenciador (Painel de Controle) da Syncfusion

Ao instalar, escolha ao menos a opção Syncfusion ASP.NET Core versão JS 2. Importante: pegue sua licença comunitária na Syncfusion antes… Ela serve para todos seus projetos.

Passo 2: Instale as extensões “Syncfusion Visual Studio extension”.

Você pode definir se quer as extensões para o Visual Studio 2017, 2019 ou ambas. Notar que na verdão 2017 as opções do Syncfusion estarão na barra superior, primeiro nível. Já no 2019. procure em Extesões -> Syncfusion. Veja aqui como fazer.

Passo 3: Gere sua aplicação inicial

Duas opções para gerar:

  1.  A partir do Visual Studio: procure o template CORE MVC com a marca da SYNCFUSION (deve ser o último da lista) e gere a aplicação.
  2. A partir do Painel de Controle da Syncfusion. Neste caso, você pode pré-selecionar todos os componentes que pretende usar em seus projetos.

Nos dois casos você pode escolher se quer arquivos auxiliares locais ou em CDN (eu escolhi CDN) e o tipo de tema que vai querer usar (eu escolhi Bootstrap).

Uma vez que você criou o projeto, rode em debug para ver se está OK na máquina local.

Passo 4: Instale a Identidade/Autorização da Microsoft

  • Clique (com o botão da direita) no nome de seu  projeto no Solution Explorer do Visual Studio. Você deverá rodar o Identity Scafolder;  Add > New Scaffolded Item.
  • No painel esquerdo do diálogo Add Scafold,  selecione  Identity > ADD;
  • No Add Identity, selecione as opções que você vai querer usar (tipo págias de deleção, de troca de senha, de confirmação de e-mail, etc – além da página de login);
    • Selecione a página de layout que você já possui (_layout.cshtm, normalmente em Views/Shared). Do contrário, seu arquivo de layout será escrito com códigos incorretos. Por exemplo , escolha ~/Pages/Shared/_Layout.cshtml  se você tiver páginas Razor. Ou <~/Views/Shared/_Layout.cshtml para projetos MVC (seu caso deve ser este)
    • Selecione o botá + para criar uma Classe de Contexto de Dados (Data context class) . O sistema vai sugerir um, use esse. Se não sugerir, defina um,
  • Selecione ADD.

Passo 5: Acertando o arquivo de Layout (_layout.cshtm)

Para poder “ver” os dados de login assim que rodar a aplicação, é fundamental adicionar no seu arquivo  Views/Shared/_Layout.cshtml o login parcial ( (_loginPartial). Para isso terá que inserir <partial name=“_LoginPartial” />. Como a aplicação usa cookies, também terá de inserir <partial name=”_CookieConsentPartial” />. Veja no arquido de exemplo abaixo onde  deve inserir esses comandos. No SEU próprio arquivo, nã mude MAIS NADA a não ser incluir essas duas linha. Veja um exemplo abaixo (não copie todas as linhas para o seu arquivo  Views/Shared/_Layout.cshtml.

Você tem muitas outras opções de incluir ou alterar a identidade. Basta conferir no artigo “Scaffold Identity in ASP.NET Core projects” da Microsoft.

Passo 6 – Preparando o banco de dados

Muito provavelmente sua aplicação vai rodar em um servidor externo MYSQL ou MSSQL.

Crie o database em vazio (sem tabelas ainda) e pegue a definição da string de conexão. Exemplo:

“Data Source=EndereçoDoServidor;Initial Catalog=NomeDOBancoDeDados;User Id=NomeDoUsuario;Password=SenhaDoUsuario;”

No arquivo appsetings,json TROQUE a string de conexão gerada na criação do seu aplicativo pela sua string de conexão.

Passo 7 – Fazendo o Scafolding acertar seu banco de dados, criando as tabelas para identificação e autorização

A identidade é essencialmente configurada em Areas/Identity/IdentityHostingStartup.cs. Para mais informações, consulte IHostingStartup.

As tabelas do banco de dados para Identidade e Autorização requerem o uso do Entity Framework Core Migrations. Será necessário fazer uma migração e autulizar o banco de dados. Isso pode ser feito em Tools->NudgePackageManager->PacketManagerConsole (usuamente chamada de PMC). Rode os seguintes comando:

 

O parâmetro “CreateIdentitySchema” psrs o comando Add-Migration descreve no nome da migração. Ele é opcional, mas é sempre últil dar um nome para você lembrar depois o que essa migração fez (criou nova tabela, modificou uma tabela, acrescentou um campo, eliminou um campo, etc.

No arquivo startup.cs é fundamental ter certeza que estão as seguintes linhas de configuração da aplicação:

app.UseStaticFiles();

app.UseAuthentication();

A segunda linha é fundamental. Veja abaixo onde encaixar essas 2 linhas:

Agora você pode rodar sua aplicação localmente e fazer os ajustes que quiser. Os 2 artigos da referência dão muitas dicas, inclusive para implementar o serviço de e-mail e alterar páginas Razor.