ASP.NET Blazor Annotations

aspnetBlazorAnnotations.md

ASP.NET Blazor Annotations

Exemplo de uma classe Context : DbContext

public class AppDbContext : DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
        { }
        public DbSet<Categoria> Categorias { get; set; }
        public DbSet<Produto> Produtos { get; set; }
    }

"AddDbContext" em "Configure Services"

var connection = Configuration["ConexaoMySqlLocal:MySqlConnectionString"];
services.AddDbContext<AppDbContext>(Options => Options.UseMySQL(connection));

appsettings para banco de dados

"AllowedHosts": "*",
  "ConexaoMySqlLocal": {
    "MySqlConnectionString": "Server=localhost;DataBase=blazorteste;Uid=root;Pwd=admin"
  }

---

Exemplo de CascadingParameter

[CascadingParameter]
    private Task<AuthenticationState> authenticationState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        var authState = await authenticationState;
        var user = authState.User;

        if (user.Identity.IsAuthenticated)
        {
            Console.WriteLine($"Bem-Vindo, {user.Identity.Name}!");
            if (user.IsInRole("Admin"))
            {
                Console.WriteLine($"Você faz parte do grupo Admin!");
            }
        }
        else
        {
            Console.WriteLine($"Usuário não autorizado!");
        }
    }

Controller para model "Categoria" (macoratti.com)

public class CategoriaController : ControllerBase
    {
        private readonly AppDbContext context;
        public CategoriaController(AppDbContext context)
        {
            this.context = context;
        }

        [HttpGet("todas")]
        public  async Task<ActionResult<List<Categoria>>> Get()
        {
            return await context.Categorias.AsNoTracking().ToListAsync();
        }

        [HttpGet]
        public async Task<ActionResult<List<Categoria>>> Get([FromQuery] Paginacao paginacao, 
            [FromQuery] string nome)
        {
            var queryable = context.Categorias.AsQueryable();

            if(!string.IsNullOrEmpty(nome))
            {
                queryable = queryable.Where(x => x.Nome.Contains(nome));
            }
            
            await HttpContext.InserirParametroEmPageResponse(queryable, paginacao.QuantidadePorPagina);
            return await queryable.Paginar(paginacao).ToListAsync();
        }

        //Buscar e Coletar uma Categoria
        [HttpGet("{id}", Name = "GetCategoria")]
        public async Task<ActionResult<Categoria>> Get(int id)
        {
            return await context.Categorias.FirstOrDefaultAsync(x => x.CategoriaId == id);
        }

        //Nova Categoria
        [HttpPost]
        public async Task<ActionResult<Categoria>> Post(Categoria categoria)
        {
            context.Add(categoria);
            await context.SaveChangesAsync();
            return new CreatedAtRouteResult("GetCategoria",
                new { id = categoria.CategoriaId }, categoria);
        }

        //Editar Categoria
        [HttpPut]
        public async Task<ActionResult<Categoria>> Put(Categoria categoria)
        {
            context.Entry(categoria).State = EntityState.Modified;
            await context.SaveChangesAsync();
            return Ok(categoria);
        }

        //Remover Categoria
        [HttpDelete("{id}")]
        public async Task<ActionResult<Categoria>> Delete(int id)
        {
            var categoria = new Categoria { CategoriaId = id };
            context.Remove(categoria);
            await context.SaveChangesAsync();
            return Ok(categoria);
        }
    }

Componente CategoriaForm

<EditForm Model="@Categoria" OnValidSubmit="@OnValidSubmit">
    <DataAnnotationsValidator></DataAnnotationsValidator>
    <ValidationSummary></ValidationSummary>
    <div class="form-group">
        <label form="nome">Nome</label>
        <div>
            <InputText @bind-Value="@Categoria.Nome" class="form-control"></InputText>
            <ValidationMessage For="@(()=>Categoria.Nome)"></ValidationMessage>
        </div>
    </div>
    <div class="form-group">
        <label form="nome">Descrição</label>
        <div>
            <InputText @bind-Value="@Categoria.Descricao" class="form-control"></InputText>
            <ValidationMessage For="@(()=>Categoria.Descricao)"></ValidationMessage>
        </div>
    </div>
    <button type="submit" class="btn btn-success">@ButtonTextSubmit</button>
    <button type="submit" class="btn btn-danger" @onclick="@(()=> navigation.NavigateTo("categoria"))">@ButtonTextCancelar</button>
</EditForm>

@code {
    [Inject]
    public NavigationManager navigation { get; set; }

    [Parameter]
    public Categoria Categoria { get; set; }

    [Parameter]
    public string ButtonTextSubmit { get; set; } = "Salvar";

    [Parameter]
    public string ButtonTextCancelar { get; set; } = "Cancelar";

    [Parameter]
    public EventCallback OnValidSubmit { get; set; }
}

Edit Categoria (.razor)

@page "/categoria/edit/{categoriaid:int}"
@inject HttpClient  http
@inject NavigationManager navigation

<h2>Editar Categoria</h2>

<CategoriaForm Categoria="@categoria" OnValidSubmit="@EditarCategoria"
               ButtonTextSubmit="Salvar" ButtonTextCancelar="Cancelar">

</CategoriaForm>

@code {

    [Parameter]
    public int categoriaid { get; set; }

    Categoria categoria = new Categoria();

    protected async override Task OnParametersSetAsync()
    {
        categoria =
        await http.GetFromJsonAsync<Categoria>($"api/categoria/{categoriaid}");
    }

    async Task EditarCategoria()
    {
        await http.PutAsJsonAsync("api/categoria", categoria);
        navigation.NavigateTo("categoria");
    }
}

HttpContextExtensions

public static class HttpContextExtensions
    {
        public async static Task InserirParametroEmPageResponse<T>(this HttpContext context,
           IQueryable<T> queryable, int quantidadeTotalRegistrosAExibir)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            double quantidadeRegistrosTotal = await queryable.CountAsync();
            double totalPaginas = Math.Ceiling(quantidadeRegistrosTotal / quantidadeTotalRegistrosAExibir);

            //salvando as informações no header do response
            context.Response.Headers.Add("quantidadeRegistrosTotal", quantidadeRegistrosTotal.ToString());
            context.Response.Headers.Add("totalPaginas", totalPaginas.ToString());
        }
    }

Componente "Paginacao" (Pagination)

@code {

    [Parameter] public int paginaAtual { get; set; } = 1;
    [Parameter] public int QuantidadeTotalPaginas { get; set; }
    [Parameter] public int Raio { get; set; } = 3;
    [Parameter] public EventCallback<int> PaginaSelecionada  { get; set; }

    List<LinkModel> links;

    private async Task PaginaSelecionadaLink(LinkModel link)
    {
        if(link.Page == paginaAtual)
        {
            return;
        }

        if (!link.Enabled)
        {
            return;
        }

        paginaAtual = link.Page;
        await PaginaSelecionada.InvokeAsync(link.Page);
    }

    class LinkModel
    {
        public LinkModel(int page) : this(page, true)
        { }

        public LinkModel(int page, bool enabled) : this(page, enabled, page.ToString())
        { }

        public LinkModel(int page, bool enabled, string text)
        {
            Page = page;
            Enabled = enabled;
            Text = text;
        }

        public string Text { get; set; }
        public int Page { get; set; }
        public bool Enabled { get; set; } = true;
        public bool Active { get; set; } = false;
    }

    protected override void OnParametersSet()
    {
        CarregaPaginas();
    }


    private void CarregaPaginas()
    {
        links = new List<LinkModel>();

        //tratar o link da pagina anterior
        var isLinkPaginaAnteriorHabilitado = paginaAtual != 1;
        var paginaAnterior = paginaAtual - 1;

        links.Add(new LinkModel(paginaAnterior, isLinkPaginaAnteriorHabilitado, "Anterior"));

        //trata os links das paginas especificas
        for(int i=1; i<= QuantidadeTotalPaginas; i++)
        {
            if (i >= paginaAtual - Raio && i <= paginaAtual + Raio)
            {
                links.Add(new LinkModel(i)
                {
                    Active = paginaAtual == i
                });
            }
        }

        //trata o link para a proxima pagina
         var isLinkProximaPaginaHabilitado = paginaAtual != QuantidadeTotalPaginas;
        var proximaPagina = paginaAtual + 1;

        links.Add(new LinkModel(proximaPagina, isLinkProximaPaginaHabilitado, "Próximo"));
    }

}

---

DemoAuthStateProvider

public class DemoAuthStateProvider : AuthenticationStateProvider
    {
        public async override Task<AuthenticationState> GetAuthenticationStateAsync()
        {
            await Task.Delay(4000);
            //indicamos se o usuário esta autenticado e também os seus claims
            var usuario = new ClaimsIdentity();

            return await Task.FromResult(new AuthenticationState(
                new ClaimsPrincipal(usuario)));
        }
    }

Authentication no Startup.cs

public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddAuthorizationCore();
            services.AddScoped<AuthenticationStateProvider, DemoAuthStateProvider>();
        }

        public void Configure(IComponentsApplicationBuilder app)
        {
            app.AddComponent<App>("app");
        }
    }