Crear una API RESTful

Crear la clase MongoDBSettings

Su servicio de MongoDB es responsable de establecer una conexión y trabajar directamente con documentos dentro de MongoDB. En su proyecto, cree una carpeta llamada Models. En la carpeta Models, crear un nuevo archivo llamado MongoDBSettings.cs. En este archivo, agregue el siguiente código:

namespace MongoExample.Models;
public class MongoDBSettings {
    public string ConnectionURI { get; set; } = null!;
    public string DatabaseName { get; set; } = null!;
    public string CollectionName { get; set; } = null!;
}

El código anterior define una clase llamada MongoDBSettings que contiene información sobre tu conexión, el nombre de la base de datos y el nombre de la colección.

Actualiza el archivo appsettings.json

Puede encontrar los datos que se almacenan en los campos de clase definidos en la clase MongoDBSettings en el archivo appsettings.json de los proyectos. Abre este archivo y agrega la siguiente configuración:

{
   "Logging": {
      "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
      }
   },
   "AllowedHosts": "*",
   "MongoDB": {
      "ConnectionURI": "<Atlas connection string>",
      "DatabaseName": "sample_mflix",
      "CollectionName": "playlist"
      }
}

Este tutorial utiliza la base de datos sample_mflix y la colección playlist. Reemplace el marcador de posición <Atlas connection string> con su cadena de conexión de MongoDB Atlas. Para obtener más información sobre cómo encontrar tu cadena de conexión, consulta el tutorial Conéctate a tu clúster en la documentación de Atlas.

Crea el servicio

En tu proyecto, crea una carpeta llamada Services. En la carpeta Services, crea un archivo llamado MongoDBService.cs y añade el siguiente código:

using MongoExample.Models;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using MongoDB.Bson;
namespace MongoExample.Services;
public class MongoDBService {
    private readonly IMongoCollection<Playlist> _playlistCollection;
    public MongoDBService(IOptions<MongoDBSettings> mongoDBSettings) {
        MongoClient client = new MongoClient(mongoDBSettings.Value.ConnectionURI);
        IMongoDatabase database = client.GetDatabase(mongoDBSettings.Value.DatabaseName);
        _playlistCollection = database.GetCollection<Playlist>(mongoDBSettings.Value.CollectionName);
    }
    public async Task<List<Playlist>> GetAsync() { }
    public async Task CreateAsync(Playlist playlist) { }
    public async Task AddToPlaylistAsync(string id, string movieId) {}
    public async Task DeleteAsync(string id) { }
}

El código anterior define una clase llamada MongoDBService que incluye funciones asíncronas vacías. A lo largo de este tutorial, agregará código a estas funciones a medida que cree sus puntos finales. La configuración que estableciste en el archivo appsettings.json se asignó a variables.

Conecta el servicio a la aplicación

Abre el archivo Program.cs y añade el siguiente código en la parte superior del archivo:

using MongoExample.Models;
using MongoExample.Services;
var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<MongoDBSettings>(builder.Configuration.GetSection("MongoDB"));
builder.Services.AddSingleton<MongoDBService>();

En el código anterior, la función GetSection() extrae la configuración del campo MongoDB en el archivo appsettings.json.

Crea el modelo orientado a documentos

Ahora que el servicio está configurado, puede crear un modelo de datos para su colección.

En la carpeta Models, crea un nuevo archivo llamado Playlist.cs y agrega el siguiente código:

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace MongoExample.Models;
public class Playlist {
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string? Id { get; set; }
    public string username { get; set; } = null!;
    [BsonElement("items")]
    [JsonPropertyName("items")]
    public List<string> movieIds { get; set; } = null!;
}

En el código anterior, el campo Id se serializa como un ObjectId en el campo _id. El campo se representa como una string en su aplicación.

El campo movieIds se serializa como items. Cuando envíes o recibas valores JSON, el campo también se denomina items en lugar de movieIds.

Si se planea que el campo de clase local coincida directamente con el campo del documento, no es necesario definir mapeos personalizados. Por ejemplo, el campo username en el código anterior no tiene asignaciones personalizadas. Se le llama "username" en C#, en JSON y en MongoDB.

Crear un controlador

En tu proyecto, crea una carpeta llamada Controllers. En la carpeta Controllers, crea un archivo llamado PlaylistController.cs y añade el siguiente código:

using System;
using Microsoft.AspNetCore.Mvc;
using MongoExample.Services;
using MongoExample.Models;
namespace MongoExample.Controllers; 
[Controller]
[Route("api/[controller]")]
public class PlaylistController: Controller {
    
    private readonly MongoDBService _mongoDBService;
    public PlaylistController(MongoDBService mongoDBService) {
        _mongoDBService = mongoDBService;
    }
    [HttpGet]
    public async Task<List<Playlist>> Get() {}
    [HttpPost]
    public async Task<IActionResult> Post([FromBody] Playlist playlist) {}
    [HttpPut("{id}")]
    public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {}
    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(string id) {}
}

La clase PlaylistController contiene un método constructor que obtiene acceso a su clase de servicio singleton. Luego, hay una serie de endpoints para este controlador.

Añadir datos mediante el endpoint POST

Ve a Services/MongoDBService.cs y actualiza la función CreateAsync para usar el siguiente código:

public async Task CreateAsync(Playlist playlist) { 
  await _playlistCollection.InsertOneAsync(playlist);
  return;
}

El código anterior establece la _playlistCollection en el método constructor del servicio. Esto le permite a su aplicación utilizar el método InsertOneAsync, que toma una variable Playlist transmitida e inserta.

Para completar la creación del punto final POST, vaya al archivo Controllers/PlaylistController.cs y actualice el método Post para usar el siguiente código:

[HttpPost]
public async Task<IActionResult> Post([FromBody] Playlist playlist) {
  await _mongoDBService.CreateAsync(playlist);
  return CreatedAtAction(nameof(Get), new { id = playlist.Id }, playlist);
}

Cuando se ejecuta el punto de conexión POST, la aplicación toma el objeto Playlist de request, que .NET Core analiza, y lo pasa a la función CreateAsync del servicio. Tras la inserción, el código devuelve información sobre la interacción.

Leer datos a través del punto final GET

Ve a Services/MongoDBService.cs y actualiza la función GetAsync para usar el siguiente código:

public async Task<List<Playlist>> GetAsync() { 
  return await _playlistCollection.Find(new BsonDocument()).ToListAsync();
}

La operación Find en el código anterior devuelve todos los documentos que existen en la colección.

Para completar la creación del punto final GET, vaya al archivo Controllers/PlaylistController.cs y actualice el método Get para usar el siguiente código:

[HttpGet]
public async Task<List<Playlist>> Get() {
  return await _mongoDBService.GetAsync();
}

Actualizar datos usando el endpoint PUT

Ve a Services/MongoDBService.cs y actualiza la función AddToPlaylistAsync para usar el siguiente código:

public async Task AddToPlaylistAsync(string id, string movieId) {
  FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
  UpdateDefinition<Playlist> update = Builders<Playlist>.Update.AddToSet<string>("movieIds", movieId);
  await _playlistCollection.UpdateOneAsync(filter, update);
  return;
}

El código anterior configura un filtro de coincidencia para determinar qué documento o documentos reciben una actualización, en este caso, agregando un elemento a tu lista de reproducción. El código coincide en base al campo Id, que es único. Luego, el código define los criterios de actualización, que es una operación AddtoSet que solo agrega un elemento al arreglo si aún no existe en el arreglo.

Los métodos UpdateOneAsync sólo actualizan documentos, incluso si el filtro de coincidencia devuelve más de una coincidencia.

Para completar la creación del endpoint PUT, vaya al archivo Controllers/PlaylistController.cs y actualice la función AddToPlaylist para usar el siguiente código:

[HttpPut("{id}")]
public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {    
  await _mongoDBService.AddToPlaylistAsync(id, movieId);
  return NoContent();
}

Borrar datos utilizando el endpoint DELETE

Ve a Services/MongoDBService.cs y actualiza la función DeleteAsync para usar el siguiente código:

public async Task DeleteAsync(string id) {
  FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
  await _playlistCollection.DeleteOneAsync(filter);
  return;
}

El código anterior borra un único documento basado en los criterios de filtro, que coincide con el valor único del campo Id.

Para completar la creación del punto final DELETE, vaya al archivo Controllers/PlaylistController.cs y actualice la función Delete para usar el siguiente código:

[HttpDelete("{id}")]
public async Task<IActionResult> Delete(string id) {
  await _mongoDBService.DeleteAsync(id);
  return NoContent();
}