Delbert  Ferry

Delbert Ferry

1622018311

Using nullability in GraphQL

When to use non-null

Now that we’ve learned about how to actually use non-null fields and arguments and what they do, what’s the right way to use them?

One point that almost everyone seems to agree on is that it’s important to think carefully about how you use nullability in GraphQL. For example, [Caleb Meredith] mentions that “Non-null fields make it hard to evolve your schema” in his article [“When To Use GraphQL Non-Null Fields”].

#nullable #graphql #nullability #null

What is GEEK

Buddha Community

Using nullability in GraphQL
Delbert  Ferry

Delbert Ferry

1622018311

Using nullability in GraphQL

When to use non-null

Now that we’ve learned about how to actually use non-null fields and arguments and what they do, what’s the right way to use them?

One point that almost everyone seems to agree on is that it’s important to think carefully about how you use nullability in GraphQL. For example, [Caleb Meredith] mentions that “Non-null fields make it hard to evolve your schema” in his article [“When To Use GraphQL Non-Null Fields”].

#nullable #graphql #nullability #null

Why Use WordPress? What Can You Do With WordPress?

Can you use WordPress for anything other than blogging? To your surprise, yes. WordPress is more than just a blogging tool, and it has helped thousands of websites and web applications to thrive. The use of WordPress powers around 40% of online projects, and today in our blog, we would visit some amazing uses of WordPress other than blogging.
What Is The Use Of WordPress?

WordPress is the most popular website platform in the world. It is the first choice of businesses that want to set a feature-rich and dynamic Content Management System. So, if you ask what WordPress is used for, the answer is – everything. It is a super-flexible, feature-rich and secure platform that offers everything to build unique websites and applications. Let’s start knowing them:

1. Multiple Websites Under A Single Installation
WordPress Multisite allows you to develop multiple sites from a single WordPress installation. You can download WordPress and start building websites you want to launch under a single server. Literally speaking, you can handle hundreds of sites from one single dashboard, which now needs applause.
It is a highly efficient platform that allows you to easily run several websites under the same login credentials. One of the best things about WordPress is the themes it has to offer. You can simply download them and plugin for various sites and save space on sites without losing their speed.

2. WordPress Social Network
WordPress can be used for high-end projects such as Social Media Network. If you don’t have the money and patience to hire a coder and invest months in building a feature-rich social media site, go for WordPress. It is one of the most amazing uses of WordPress. Its stunning CMS is unbeatable. And you can build sites as good as Facebook or Reddit etc. It can just make the process a lot easier.
To set up a social media network, you would have to download a WordPress Plugin called BuddyPress. It would allow you to connect a community page with ease and would provide all the necessary features of a community or social media. It has direct messaging, activity stream, user groups, extended profiles, and so much more. You just have to download and configure it.
If BuddyPress doesn’t meet all your needs, don’t give up on your dreams. You can try out WP Symposium or PeepSo. There are also several themes you can use to build a social network.

3. Create A Forum For Your Brand’s Community
Communities are very important for your business. They help you stay in constant connection with your users and consumers. And allow you to turn them into a loyal customer base. Meanwhile, there are many good technologies that can be used for building a community page – the good old WordPress is still the best.
It is the best community development technology. If you want to build your online community, you need to consider all the amazing features you get with WordPress. Plugins such as BB Press is an open-source, template-driven PHP/ MySQL forum software. It is very simple and doesn’t hamper the experience of the website.
Other tools such as wpFoRo and Asgaros Forum are equally good for creating a community blog. They are lightweight tools that are easy to manage and integrate with your WordPress site easily. However, there is only one tiny problem; you need to have some technical knowledge to build a WordPress Community blog page.

4. Shortcodes
Since we gave you a problem in the previous section, we would also give you a perfect solution for it. You might not know to code, but you have shortcodes. Shortcodes help you execute functions without having to code. It is an easy way to build an amazing website, add new features, customize plugins easily. They are short lines of code, and rather than memorizing multiple lines; you can have zero technical knowledge and start building a feature-rich website or application.
There are also plugins like Shortcoder, Shortcodes Ultimate, and the Basics available on WordPress that can be used, and you would not even have to remember the shortcodes.

5. Build Online Stores
If you still think about why to use WordPress, use it to build an online store. You can start selling your goods online and start selling. It is an affordable technology that helps you build a feature-rich eCommerce store with WordPress.
WooCommerce is an extension of WordPress and is one of the most used eCommerce solutions. WooCommerce holds a 28% share of the global market and is one of the best ways to set up an online store. It allows you to build user-friendly and professional online stores and has thousands of free and paid extensions. Moreover as an open-source platform, and you don’t have to pay for the license.
Apart from WooCommerce, there are Easy Digital Downloads, iThemes Exchange, Shopify eCommerce plugin, and so much more available.

6. Security Features
WordPress takes security very seriously. It offers tons of external solutions that help you in safeguarding your WordPress site. While there is no way to ensure 100% security, it provides regular updates with security patches and provides several plugins to help with backups, two-factor authorization, and more.
By choosing hosting providers like WP Engine, you can improve the security of the website. It helps in threat detection, manage patching and updates, and internal security audits for the customers, and so much more.

Read More

#use of wordpress #use wordpress for business website #use wordpress for website #what is use of wordpress #why use wordpress #why use wordpress to build a website

Elm Graphql: Autogenerate Type-safe GraphQL Queries in Elm

dillonkearns/elm-graphql  

Why use this package over the other available Elm GraphQL packages? This is the only one that generates type-safe code for your entire schema. Check out this blog post, Type-Safe & Composable GraphQL in Elm, to learn more about the motivation for this library. (It's also the only type-safe library with Elm 0.18 or 0.19 support, see this discourse thread).

I built this package because I wanted to have something that:

  1. Gives you type-safe GraphQL queries (if it compiles, it's valid according to the schema),
  2. Creates decoders for you in a seamless and failsafe way, and
  3. Eliminates GraphQL features in favor of Elm language constructs where possible for a simpler UX (for example, GraphQL variables & fragments should just be Elm functions, constants, lets).

See an example in action on Ellie. See more end-to-end example code in the examples/ folder.

Overview

dillonkearns/elm-graphql is an Elm package and accompanying command-line code generator that creates type-safe Elm code for your GraphQL endpoint. You don't write any decoders for your API with dillonkearns/elm-graphql, instead you simply select which fields you would like, similar to a standard GraphQL query but in Elm. For example, this GraphQL query

query {
  human(id: "1001") {
    name
    homePlanet
  }
}

would look like this in dillonkearns/elm-graphql (the code in this example that is prefixed with StarWars is auto-generated)

import Graphql.Operation exposing (RootQuery)
import Graphql.SelectionSet as SelectionSet exposing (SelectionSet)
import StarWars.Object
import StarWars.Object.Human as Human
import StarWars.Query as Query
import StarWars.Scalar exposing (Id(..))


query : SelectionSet (Maybe HumanData) RootQuery
query =
    Query.human { id = Id "1001" } humanSelection


type alias HumanData =
    { name : String
    , homePlanet : Maybe String
    }


humanSelection : SelectionSet HumanData StarWars.Object.Human
humanSelection =
    SelectionSet.map2 HumanData
        Human.name
        Human.homePlanet

GraphQL and Elm are a perfect match because GraphQL is used to enforce the types that your API takes as inputs and outputs, much like Elm's type system does within Elm. elm-graphql simply bridges this gap by making your Elm code aware of your GraphQL server's schema. If you are new to GraphQL, graphql.org/learn/ is an excellent way to learn the basics.

After following the installation instructions to install the @dillonkearns/elm-graphql NPM package and the proper Elm packages (see the Setup section for details). Once you've installed everything, running the elm-graphql code generation tool is as simple as this:

npx elm-graphql https://elm-graphql.herokuapp.com --base StarWars --output examples/src

If headers are required, such as a Bearer Token, the --header flag can be supplied.

npx elm-graphql https://elm-graphql.herokuapp.com --base StarWars --output examples/src --header 'headerKey: header value'

Learning Resources

There is a thorough tutorial in the SelectionSet docs. SelectionSets are the core concept in this library, so I recommend reading through the whole page (it's not very long!).

The examples/ folder is another great place to start.

If you want to learn more GraphQL basics, this is a great tutorial, and a short read: graphql.org/learn/

My Elm Conf 2018 talk goes into the philosophy behind dillonkearns/elm-graphql

Types Without Borders Elm Conf Talk

(Skip to 13:06 to go straight to the dillonkearns/elm-graphql demo).

If you're wondering why code is generated a certain way, you're likely to find an answer in the Frequently Asked Questions (FAQ).

There's a very helpful group of people in the #graphql channel in the Elm Slack. Don't hesitate to ask any questions about getting started, best practices, or just general GraphQL in there!

Setup

dillonkearns/elm-graphql generates Elm code that allows you to build up type-safe GraphQL requests. Here are the steps to setup dillonkearns/elm-graphql.

Add the dillonkearns/elm-graphql elm package as a dependency in your elm.json. You will also need to make sure that elm/json is a dependency of your project since the generated code has lots of JSON decoders in it.

elm install dillonkearns/elm-graphql
elm install elm/json

Install the @dillonkearns/elm-graphql command line tool through npm. This is what you will use to generate Elm code for your API. It is recommended that you save the @dillonkearns/elm-graphql command line tool as a dev dependency so that everyone on your project is using the same version.

npm install --save-dev @dillonkearns/elm-graphql
# you can now run it locally using `npx elm-graphql`,
# or by calling it through an npm script as in this project's package.json

Run the @dillonkearns/elm-graphql command line tool installed above to generate your code. If you used the --save-dev method above, you can simply create a script in your package.json like the following:

{
  "name": "star-wars-elm-graphql-project",
  "version": "1.0.0",
  "scripts": {
    "api": "elm-graphql https://elm-graphql.herokuapp.com/api --base StarWars"
  }

With the above in your package.json, running npm run api will generate dillonkearns/elm-graphql code for you to call in ./src/StarWars/. You can now use the generated code as in this Ellie example or in the examples folder.

Subscriptions Support

You can do real-time APIs using GraphQL Subscriptions and dillonkearns/elm-graphql. Just wire in the framework-specific JavaScript code for opening the WebSocket connection through a port. Here's a live demo and its source code. The demo server is running Elixir/Absinthe.

Contributors

Thank you Mario Martinez (martimatix) for all your feedback, the elm-format PR, and for the incredible logo design!

Thank you Mike Stock (mikeastock) for setting up Travis CI!

Thanks for the reserved words pull request @madsflensted!

A huge thanks to @xtian for doing the vast majority of the 0.19 upgrade work! :tada:

Thank you Josh Adams (@knewter) for the code example for Subscriptions with Elixir/Absinthe wired up through Elm ports!

Thank you Romario for adding OptionalArgument.map!

Thank you Aaron White for your pull request to improve the performance and stability of the elm-format step! 🎉

Roadmap

All core features are supported. That is, you can build any query or mutation with your dillonkearns/elm-graphql-generated code, and it is guaranteed to be valid according to your server's schema.

dillonkearns/elm-graphql will generate code for you to generate subscriptions and decode the responses, but it doesn't deal with the low-level details for how to send them over web sockets. To do that, you will need to use custom code or a package that knows how to communicate over websockets (or whichever protocol) to setup a subscription with your particular framework. See this discussion for why those details are not handled by this library directly.

I would love to hear feedback if you are using GraphQL Subscriptions. In particular, I'd love to see live code examples to drive any improvements to the Subscriptions design. Please ping me on Slack, drop a message in the #graphql channel, or open up a Github issue to discuss!

I would like to investigate generating helpers to make pagination simpler for Connections (based on the Relay Cursor Connections Specification). If you have ideas on this chime in on this thread.

See the full roadmap on Trello.


Author: dillonkearns
Source Code: https://github.com/dillonkearns/elm-graphql
License: View license

#graphql 

Delbert  Ferry

Delbert Ferry

1622105190

How to use GraphQL with Javascript – GraphQL.js tutorial

One of the fastest ways to get up and running with GraphQL is to install Apollo Server as middleware on your new or existing HTTP server.

In this short post, we demonstrate how to use Apollo Server to create a GraphQL server with Express.js using the [apollo-server-express] package. At the end, we’ll discuss the tradeoffs of this approach.

#graphql #javascript #graphql.js #graphql.js tutorial

Saul  Alaniz

Saul Alaniz

1649591280

Consumir API Web Por MVC En .NET Core (1): Servidor Y Marco

Este artículo le brindará una manera de consumir API web mediante un cliente ASP.NET MVC en .NET Core con una línea de código.

Introducción

El microservicio es una arquitectura moderna de desarrollo de software: arquitectura poco acoplada con ámbito de aplicación. Básicamente incluye dos partes: Cliente y API.

Teóricamente, la API es un servidor, puede ser construido por cualquier lenguaje, plataforma o dispositivo.

El cliente es el consumidor del API Server que, a su vez, pueden ser aplicaciones de un teléfono inteligente, tableta, Windows, Mac o cualquier tipo de navegador, y pueden construirse para cualquier plataforma y lenguaje.

ASP.NET Web API es, específicamente, un producto de Microsoft para producir la salida RESTful a través de HTTP para Clientes. El consumidor de ASP.NET Web API podría ser:

  • cliente Javascript,
  • cliente angular,
  • cliente de Node.js,
  • cliente jQuery,
  • Código C# como Console, MVC, WebForm, Windows, etc.

En este artículo, consideraremos el cliente C# y, específicamente, un cliente ASP.NET MVC en .NET Core.

Si lo buscamos en Google, podemos encontrar muchos artículos que describen el cliente C# para consumir Web API (vea algunas de las referencias al final de este artículo). Sin embargo, la mayoría de ellos parecen bastante complejos, e incluso podrías seguir los pasos para construir un proyecto, es difícil seguir los puntos para volver a hacer uno por ti mismo.

La contribución de este artículo es que intentaré crear un código de una línea para compilar el cliente MVC. Antes del código de una línea, usaremos todo el conocimiento y las técnicas con las que estamos familiarizados para construir el marco del servidor y el cliente.

Este artículo se dividirá en dos partes, la Parte I (este artículo) creará una API web ASP.NET Core (servidor) y también un módulo ASP.NET Core MVC (base de cliente). El último se utilizará como marco del cliente MVC de código de una línea. La Parte II implementará el código de una línea Web API Client para que sea un consumidor de Web API.

R: Cree ASP.NET MVC en .NET Core con Entity Framework Database First

Esta parte creará una aplicación ASP.NET Core MVC con el primer enfoque de Entity Framework Database.

  • Paso 1: Cree una aplicación ASP.NET Core MVC
     
  • Paso 2: modelo de entidad de ingeniería inversa a partir de la base de datos (primer enfoque de la base de datos para la entidad)
  • Paso 3: Controlador de andamio con vista usando Entity Framework
  • Paso 4: Ejecutar y probar la aplicación

Al final, tiene una aplicación MVC que puede consumir una base de datos directamente a través del marco de la entidad.

Paso 1: Cree una aplicación ASP.NET Core MVC

Usamos la versión actual de Visual Studio 2019 16.8 y .NET 5.0 SDK para compilar la aplicación.

  1. Inicie Visual Studio y seleccione Crear un nuevo proyecto.
  2. En el cuadro de diálogo Crear un nuevo proyecto, seleccione Aplicación web ASP.NET Core > Siguiente.
  3. En el cuadro de diálogo Configurar su nuevo proyecto, ingrese MVCCallWebAPINombre del proyecto.
     
  4. Seleccione Crear.
  5. En el cuadro de diálogo Crear una nueva aplicación web ASP.NET Core, seleccione,

    1. .NET Core y ASP.NET Core 5.0 en los menús desplegables.
    2. Aplicación web ASP.NET Core (Modelo-Vista-Controlador).
    3. Crear

Consumir API web por cliente MVC en .NET Core, Server y Framework

Cree y ejecute la aplicación, verá que la siguiente imagen muestra la aplicación,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Paso 2: modelo de Entidad de ingeniería inversa a partir de la base de datos (primer enfoque de la base de datos para la Entidad)

Usamos un servidor SQL de Microsft local, y las publicaciones de la base de datos de muestra y su tabla se almacenan como muestra de nuestra base de datos. Intentamos aplicar ingeniería inversa para incluir la tabla Stores en el proyecto y crear un modelo de entidad Store.

Haga clic en "Herramientas->Administrador de paquetes NuGet->Consola del administrador de paquetes" como se muestra a continuación, es decir

Consumir API web por cliente MVC en .NET Core, Server y Framework

Este es el comando de ingeniería inversa (cuando ejecuta el comando en PMC, debe hacerlo en una línea),

Scaffold-DbContext "Data Source=localhost;Initial Catalog=pubs;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" Microsoft.EntityFrameworkCore.SqlServer   
-OutputDir Models/DB   
-Table dbo.stores  

Ejecute el comando en el PMC,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Recibimos un mensaje de error anterior que indica que se requiere Microsoft.EntityFrameworkCore.Design , pero no está instalado. Haga clic en "Herramientas->Administrador de paquetes NuGet->Administrar paquetes NuGet para la solución" como se muestra a continuación,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Elija e instale: Microsoft.EntityFrameworkCore.Design,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Ejecute el comando PMC nuevamente, 

Consumir API web por cliente MVC en .NET Core, Server y Framework

Obtuvimos: No se pudo encontrar el ensamblado del proveedor 'Microsoft.EntityFrameworkCore.SqlServer' , instálelo de la misma manera anterior desde Administrar paquetes NuGet para la solución y luego vuelva a ejecutar el comando PMC. Esto fue exitoso y dos clases tienen ingeniería inversa en Models/DB como se muestra a continuación: pubsContext.cs y Store.cs

Consumir API web por cliente MVC en .NET Core, Server y Framework

Paso 3: agregar controlador con vista usando Entity Framework

Para agregar un controlador usando el marco de la entidad, necesitamos modificar las clases de ingeniería inversa pubsContext y Store.cs. 

1. Modificar la conexión de datos

Para la clase pubsContext, debemos comentar la parte de conexión de datos, 

//        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)  
//        {  
//            if (!optionsBuilder.IsConfigured)  
//            {  
//#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.  
//                optionsBuilder.UseSqlServer("Data Source=localhost;Initial Catalog=pubs;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False");  
//            }  
//        }  

y mueva la cadena de conexión de datos al archivo appsettings.json,

{        
  "Logging": {        
    "LogLevel": {        
      "Default": "Information",        
      "Microsoft": "Warning",        
      "Microsoft.Hosting.Lifetime": "Information"        
    }        
  },        
        
  "ConnectionStrings": {        
    "DevConnection": "Data Source=localhost;Initial Catalog=pubs;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"        
  },        
      
  "AllowedHosts": "*"        
}    

Registre el contexto de conexión de la base de datos en Class starup.cs dentro de ConfigureServices,

public void ConfigureServices(IServiceCollection services)        
{        
    // Register SQL database configuration context as services.         
    services.AddDbContext<pubsContext>(options =>        
    {        
        options.UseSqlServer(Configuration.GetConnectionString("DevConnection"));        
    });        
        
    services.AddControllersWithViews();        
}    

De lo contrario, podríamos hacer un controlador con vista usando este marco de entidad, y esto no funcionaría.

2. Modificar el modelo

En la clase pubsContext, también podemos comentar la parte de restricción de datos, 

//protected override void OnModelCreating(ModelBuilder modelBuilder)    
//{    
//    modelBuilder.HasAnnotation("Relational:Collation", "SQL_Latin1_General_CP1_CI_AS");    
    
//    modelBuilder.Entity<Store>(entity =>    
//    {    
//        entity.HasKey(e => e.StorId)    
//            .HasName("UPK_storeid");    
    
//        entity.ToTable("stores");    
    
//        entity.Property(e => e.StorId)    
//            .HasMaxLength(4)    
//            .IsUnicode(false)    
//            .HasColumnName("stor_id")    
//            .IsFixedLength(true);    
    
//        entity.Property(e => e.City)    
//            .HasMaxLength(20)    
//            .IsUnicode(false)    
//            .HasColumnName("city");    
    
//        entity.Property(e => e.State)    
//            .HasMaxLength(2)    
//            .IsUnicode(false)    
//            .HasColumnName("state")    
//            .IsFixedLength(true);    
    
//        entity.Property(e => e.StorAddress)    
//            .HasMaxLength(40)    
//            .IsUnicode(false)    
//            .HasColumnName("stor_address");    
    
//        entity.Property(e => e.StorName)    
//            .HasMaxLength(40)    
//            .IsUnicode(false)    
//            .HasColumnName("stor_name");    
    
//        entity.Property(e => e.Zip)    
//            .HasMaxLength(5)    
//            .IsUnicode(false)    
//            .HasColumnName("zip")    
//            .IsFixedLength(true);    
//    });    
    
//    OnModelCreatingPartial(modelBuilder);    
//}    
    
//partial void OnModelCreatingPartial(ModelBuilder modelBuilder);    

pero necesitamos modificar el modelo de datos para hacer que los nombres de los miembros de la tabla sean exactamente iguales a como están en la base de datos, como StorId en Stor_Id, y agregar una [Clave] para la clave principal en la base de datos.

La clase Store.cs, antes ,

using System.ComponentModel.DataAnnotations;    
  
#nullable disable    
    
namespace MVCCallWebAPI.Models.DB    
{    
    public partial class Store    
    {    
        public string StorId { get; set; }    
        public string StorName { get; set; }    
        public string StorAddress { get; set; }    
        public string City { get; set; }    
        public string State { get; set; }    
        public string Zip { get; set; }    
    }    
}    

Después

using System.ComponentModel.DataAnnotations;    
  
#nullable disable    
    
namespace MVCCallWebAPI.Models.DB    
{    
    public partial class Store    
    {    
        [Key]    
        public string Stor_Id { get; set; }    
        public string Stor_Name { get; set; }    
        public string Stor_Address { get; set; }    
        public string City { get; set; }    
        public string State { get; set; }    
        public string Zip { get; set; }    
    }    
}   

La clase final pubsContext será,

using Microsoft.EntityFrameworkCore;  
 
#nullable disable  
  
namespace MVCCallWebAPI.Models.DB  
{  
    public partial class pubsContext : DbContext  
    {  
        public pubsContext()  
        {  
        }  
  
        public pubsContext(DbContextOptions<pubsContext> options)  
            : base(options)  
        {  
        }  
  
        public virtual DbSet<Store> Stores { get; set; }  
  
//        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)  
//        {  
//            if (!optionsBuilder.IsConfigured)  
//            {  
//#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.  
//                optionsBuilder.UseSqlServer("Data Source=localhost;Initial Catalog=pubs;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False");  
//            }  
//        }  
  
        //protected override void OnModelCreating(ModelBuilder modelBuilder)  
        //{  
        //    modelBuilder.HasAnnotation("Relational:Collation", "SQL_Latin1_General_CP1_CI_AS");  
  
        //    modelBuilder.Entity<Store>(entity =>  
        //    {  
        //        entity.HasKey(e => e.StorId)  
        //            .HasName("UPK_storeid");  
  
        //        entity.ToTable("stores");  
  
        //        entity.Property(e => e.StorId)  
        //            .HasMaxLength(4)  
        //            .IsUnicode(false)  
        //            .HasColumnName("stor_id")  
        //            .IsFixedLength(true);  
  
        //        entity.Property(e => e.City)  
        //            .HasMaxLength(20)  
        //            .IsUnicode(false)  
        //            .HasColumnName("city");  
  
        //        entity.Property(e => e.State)  
        //            .HasMaxLength(2)  
        //            .IsUnicode(false)  
        //            .HasColumnName("state")  
        //            .IsFixedLength(true);  
  
        //        entity.Property(e => e.StorAddress)  
        //            .HasMaxLength(40)  
        //            .IsUnicode(false)  
        //            .HasColumnName("stor_address");  
  
        //        entity.Property(e => e.StorName)  
        //            .HasMaxLength(40)  
        //            .IsUnicode(false)  
        //            .HasColumnName("stor_name");  
  
        //        entity.Property(e => e.Zip)  
        //            .HasMaxLength(5)  
        //            .IsUnicode(false)  
        //            .HasColumnName("zip")  
        //            .IsFixedLength(true);  
        //    });  
  
        //    OnModelCreatingPartial(modelBuilder);  
        //}  
  
        //partial void OnModelCreatingPartial(ModelBuilder modelBuilder);  
    }  
} 

3. Agrega el controlador

En el Explorador de soluciones, haga clic con el botón derecho en la carpeta Controladores > Agregar > Nuevo elemento con andamios. Luego, seleccione Controlador MVC con vistas, usando Entity Framework > Agregar.

Consumir API web por cliente MVC en .NET Core, Server y Framework

Complete Agregar controlador MVC con vistas, usando el cuadro de diálogo Entity Framework,

  • Clase de modelo -  Tienda (MVCCallWebAPI.Models.DB)
  • Clase de contexto de datos:  pubsContext (MVCCallWebAPI.Models.DB)
  • Vistas: mantenga marcada la opción predeterminada de cada opción
  • Nombre del controlador: cambie el StoresController predeterminado a StoresMVCController
  • Seleccione Agregar

Consumir API web por cliente MVC en .NET Core, Server y Framework

Visual Studio crea,

  • Un controlador StroesMVC ( Controllers/StoresMVCController.cs )
  • Archivos de vista de Razor para crear, eliminar, detalles, editar e indexar páginas ( Views/StoresMVC/*.cshtml )

Consumir API web por cliente MVC en .NET Core, Server y Framework

La creación automática de estos archivos se conoce como scaffolding .

 

Paso 4. Ejecute y pruebe la aplicación

Antes de ejecutar la aplicación, modifique el encabezado del archivo: Views/Shared/_layout.cshtml Views, que se muestra a continuación, cambie el controlador como StoreMVC y el nombre de la aplicación como aplicación MVC:

<header>    
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">    
        <div class="container">    
            <a class="navbar-brand" asp-area="" asp-controller="StroeMVC" asp-action="Index">MVC app</a>    
            <button class="navbar-toggler" type="button" data-toggle="collapse" data-target=".navbar-collapse" aria-controls="navbarSupportedContent"    
                    aria-expanded="false" aria-label="Toggle navigation">    
                <span class="navbar-toggler-icon"></span>    
            </button>    
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">    
                <ul class="navbar-nav flex-grow-1">    
                    <li class="nav-item">    
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>    
                    </li>    
                    <li class="nav-item">    
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>    
                    </li>    
                </ul>    
            </div>    
        </div>    
    </nav>    
</header>    

Ahora, ejecutamos la aplicación,

 

Consumir API web por cliente MVC en .NET Core, Server y Framework

Haga clic en la aplicación MVC, tenemos la pantalla,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Esta es una aplicación MVC que consume la base de datos directamente a través del marco de la entidad.

B: Agregue la API web con el código de Entity Framework primero

Esta parte agregará una API web de ASP.NET Core a la aplicación con el primer enfoque del código de Entity Framework.

  • Paso 1: configurar un nuevo contexto de base de datos
     
  • Paso 2: Trabaje con una base de datos usando el código de Entity Framework primero.
  • Paso 3: controlador API Scaffold con acción usando Entity Framework
  • Paso 4: agregue el cliente Swagger para la API web
  • Paso 5: Ejecutar y probar la aplicación

Al final, tiene una API web integrada en una aplicación MVC. La API web es consumida por la interfaz de Swagger y puede ser consumida por cualquier otra interfaz, como Postman.

Paso 1: configurar un nuevo contexto de base de datos

Creamos un nuevo contexto de base de datos con el mismo modelo, Model/Store.cs , y una base de datos diferente, DB_Demo_API :

1. Cree una nueva clase de contexto de base de datos, denominada DB_Demo_APIContext.cs,

using Microsoft.EntityFrameworkCore;    
  
#nullable disable    
    
namespace MVCCallWebAPI.Models.DB    
{    
    public partial class DB_Demo_APIContext : DbContext    
    {    
        public DB_Demo_APIContext()    
        {    
        }    
    
        public DB_Demo_APIContext(DbContextOptions<DB_Demo_APIContext> options)    
            : base(options)    
        {    
        }    
    
        public virtual DbSet<Store> Stores { get; set; }    
    
    }    
}    

2. Agregue la nueva conexión en el archivo appsettings.json ,

{        
  "Logging": {        
    "LogLevel": {        
      "Default": "Information",        
      "Microsoft": "Warning",        
      "Microsoft.Hosting.Lifetime": "Information"        
    }        
  },        
        
  "ConnectionStrings": {        
    "DevConnection": "Data Source=localhost;Initial Catalog=pubs;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"        
  },        
        
  "ConnectionStrings": {        
    "DB_Demo_APIConnection": "Data Source=localhost;Initial Catalog=DB_Demo_API;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"        
  },        
        
  "AllowedHosts": "*"        
}   

3. Registre el contexto de conexión de la base de datos en Class starup.cs dentro de ConfigureServices,

public void ConfigureServices(IServiceCollection services)      
{       
    // Register SQL database configuration context as services.       
    services.AddDbContext<pubsContext>(options =>      
    {  options.UseSqlServer(Configuration.GetConnectionString("DevConnection"));      
    });      
    services.AddDbContext<DB_Demo_APIContext>(options =>      
    {      
        options.UseSqlServer(Configuration.GetConnectionString("DB_Demo_APIConnection"));      
    });      
      
    services.AddControllersWithViews();      
}     

Paso 2: Trabaje con una base de datos usando el código de Entity Framework primero.

Haga clic en "Herramientas->Administrador de paquetes NuGet->Consola del administrador de paquetes" (consulte el paso A 2) y ejecute el comando PMC (hazlos en una sola línea),

  1. Añadir-Migración
  2. -Nombre inicialMigración
  3. -Context DB_Demo_APIContext

Tenemos dos archivos de migración en la carpeta Migración,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Ejecutar comando PMC

  1. Actualizar base de datos
  2. -Nombre inicialMigración
  3. -Context DB_Demo_APIContext

Obtuvimos la tabla de base de datos Stores creada en la base de datos DB_Demo_API

Consumir API web por cliente MVC en .NET Core, Server y Framework

Paso 3: Controlador API Scaffold con acción usando Entity Framework

Haga clic con el botón derecho en la carpeta Controladores .

Seleccione Agregar > Nuevo elemento con scaffolding.

Seleccione Controlador de API con acciones mediante Entity Framework y luego seleccione Agregar.

Consumir API web por cliente MVC en .NET Core, Server y Framework

En Agregar controlador de API con acciones, mediante el cuadro de diálogo Entity Framework,
 

  • Clase de modelo - Tienda (MVCCallWebAPI.Models.DB)
  • Clase de contexto de datos:  DB_Demo_APIContext (MVCCallWebAPI.Models.DB)
  • Nombre del controlador: cambie el StoresController predeterminado a StoresWebAPIController
  • Seleccione Agregar

     

Consumir API web por cliente MVC en .NET Core, Server y Framework

 

El código generado,

  • Marca la clase con el [ApiController]atributo. Este atributo indica que el controlador responde a las solicitudes de API web.
  • Utiliza DI para inyectar el contexto de la base de datos ( DB_Demo_APIContext) en el controlador. El contexto de la base de datos se usa en cada uno de los métodos CRUD en el controlador.

Paso 4: agregue el cliente Swagger para la API web

Swagger (OpenAPI) es una especificación independiente del idioma para describir las API REST. Permite que tanto las computadoras como los humanos comprendan las capacidades de una API REST sin acceso directo al código fuente. La interfaz de usuario de Swagger ofrece una interfaz de usuario basada en web que proporciona información sobre el servicio mediante la especificación OpenAPI generada.

Si creamos un nuevo proyecto de Web API, Swagger ciente para Web API se instalaría de forma predeterminada. En nuestro caso actual, la API web se crea en un módulo MVC, por lo que debemos instalar Swagger manualmente.

1. Instalar el cliente Swagger

Haga clic con el botón derecho en el proyecto en el Explorador de soluciones > Administrar paquetes NuGet, busque Swagger

Consumir API web por cliente MVC en .NET Core, Server y Framework

Hay tres componentes principales para Swashbuckle (Swagger), solo necesitamos instalar dos de ellos: SwaggerGen y SwaggerUI, el Swagger estaría incluido.

2. Registre el cliente Swagger en el archivo startup.json

Agregue el generador Swagger a la colección de servicios en el Startup.ConfigureServicesmétodo,

// This method gets called by the runtime. Use this method to add services to the container.        
public void ConfigureServices(IServiceCollection services)        
{        
    // Register the Swagger generator, defining 1 or more Swagger documents        
    services.AddSwaggerGen(c =>        
    {        
        c.SwaggerDoc("v2", new OpenApiInfo { Title = "MVCCallWebAPI", Version = "v2" });        
    });        
    ......      
}   

Habilite el middleware para servir el documento JSON generado y la interfaz de usuario de Swagger, en el Startup.Configuremétodo,

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.        
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)        
{        
    // Enable middleware to serve generated Swagger as a JSON endpoint.        
    app.UseSwagger();        
        
    // Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),        
    // specifying the Swagger JSON endpoint.        
    app.UseSwaggerUI(c =>        
    {        
        c.SwaggerEndpoint("/swagger/v2/swagger.json", "MVCCallWebAPI");        
    });        
    ......      
}      

Ahora, estamos casi listos para ejecutar la aplicación.

Paso 5: Ejecute y pruebe la aplicación

Antes de ejecutar la aplicación, modifique el encabezado del archivo: Views/Shared/_layout.cshtml Views nuevamente, como se muestra a continuación,

<header>        
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">        
        <div class="container">        
            <a class="navbar-brand" asp-area="" asp-controller="StoresMVC" asp-action="Index">MVC app</a>        
            <button class="navbar-toggler" type="button" data-toggle="collapse" data-target=".navbar-collapse" aria-controls="navbarSupportedContent"        
                    aria-expanded="false" aria-label="Toggle navigation">        
                <span class="navbar-toggler-icon"></span>        
            </button>        
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">        
                <ul class="navbar-nav flex-grow-1">        
                    <li class="nav-item">        
                        <a class="nav-link text-dark" asp-area="" asp-controller="Swagger" asp-action="Index">Web API</a>        
                    </li>        
                    <li class="nav-item">        
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>        
                    </li>        
                    <li class="nav-item">        
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>        
                    </li>        
                </ul>        
            </div>        
        </div>        
    </nav>        
</header>       

Ahora, ejecutamos la aplicación,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Haga clic en API web, tenemos la pantalla del cliente Swagger,

Consumir API web por cliente MVC en .NET Core, Server y Framework

Resumen

En este artículo (parte I), creamos una aplicación ASP.NET Core 5.0 MVC y la asociamos con un servicio API web en ella.

  • MVC es una aplicación cliente/servidor, con una página web como cliente y un servidor SQL como servidor, enlazados por Entity Framework;
  • La API web es un servicio del lado del servidor, con una salida RESTful para el consumidor que está vinculada a la base de datos por el marco de la entidad.

Para nuestros propósitos de prueba, MVC y Web API están en contra de dos bases de datos diferentes, MVC está en contra de las publicaciones de base de datos, mientras que Web API está en contra de la base de datos DB_Demo_API, lo que también nos dio la oportunidad de practicar el primer enfoque de la base de datos del marco de la entidad y el primer enfoque del código, respectivamente, en este mini proyecto.

En el siguiente  artículo, parte II , demostraremos el enfoque de código de una línea para que el cliente MVC consuma Web API .   

Fuente: https://www.c-sharpcorner.com/article/consume-web-api-by-mvc-client-in-net-core/

 #aspdotnet #webapi #mvc