c# - custom - odata web api without entity framework

Error de OData: la consulta especificada en el URI no es válida. La propiedad no puede ser utilizada en la opción de consulta

Question

Estoy tratando de poner en funcionamiento un punto final de OData y tengo este error que incluso Google no tiene mucho que decir al respecto.

Creé un contexto Entity Framework EDMX (primero la base de datos), si el diseñador generó 2 modelos a partir de él.

Todo está funcionando bien, excepto $filter búsquedas de $filter fallan.

Puedo hacer esto bien:

http://localhost:27164/Projects(6587660)

Lo cual recupera el Proyecto con una ID primaria de 6587660.

Pero cualquier solicitud de $filter como tal:

http://localhost:27164/Projects?$filter=ProjectID eq 6587660

Fallará con el siguiente error:

La consulta especificada en el URI no es válida. La propiedad ''ProjectID'' no se puede usar en la opción de consulta $ filter.

También intenté consultar otras propiedades, también propiedades de cadenas. Mismo error.

Comprobé que el modelo generado por EF no tiene ningún atributo en las propiedades, pero no es así.

Aquí está mi método de registro en el módulo WebApiConfig.cs:

using System.Web.OData.Builder;
using System.Web.OData.Extensions;

public static void Register(HttpConfiguration config)
{
    // Web API configuration and services
    // Configure Web API to use only bearer token authentication.
    config.SuppressDefaultHostAuthentication();
    config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));


    ODataModelBuilder builder = new ODataConventionModelBuilder();
    builder.EntitySet<DB.Project>("Projects");
    config.MapODataServiceRoute(
        routeName: "ODataRoute",
        routePrefix: null,
        model: builder.GetEdmModel()
    );           

}

Aquí está el controlador de proyectos (GetProjects es el método llamado al hacer una consulta de $ filter):

public class ProjectsController : ODataController
{
    private AppContext db = new AppContext();

    //I''ve tried decorating with that: [EnableQuery(AllowedQueryOptions = System.Web.OData.Query.AllowedQueryOptions.All, AllowedArithmeticOperators = System.Web.OData.Query.AllowedArithmeticOperators.All)] and no go
    [EnableQuery]
    public IQueryable<Project> GetProjects()
    {
        return db.Projects;
    }

    // GET: odata/Projects(5)
    [EnableQuery]
    public SingleResult<Project> GetProject([FromODataUri] int key)
    {
        return SingleResult.Create(db.Projects.Where(project => project.ProjectID == key));
    }

    /*
    // PUT: odata/Projects(5)
    public IHttpActionResult Put([FromODataUri] int key, Delta<Project> patch)
    {
        Validate(patch.GetEntity());

        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        Project project = db.Projects.Find(key);
        if (project == null)
        {
            return NotFound();
        }

        patch.Put(project);

        try
        {
            db.SaveChanges();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!ProjectExists(key))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return Updated(project);
    }

    // POST: odata/Projects
    public IHttpActionResult Post(Project project)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        db.Projects.Add(project);
        db.SaveChanges();

        return Created(project);
    }

    // PATCH: odata/Projects(5)
    [AcceptVerbs("PATCH", "MERGE")]
    public IHttpActionResult Patch([FromODataUri] int key, Delta<Project> patch)
    {
        Validate(patch.GetEntity());

        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        Project project = db.Projects.Find(key);
        if (project == null)
        {
            return NotFound();
        }

        patch.Patch(project);

        try
        {
            db.SaveChanges();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!ProjectExists(key))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return Updated(project);
    }

    // DELETE: odata/Projects(5)
    public IHttpActionResult Delete([FromODataUri] int key)
    {
        Project project = db.Projects.Find(key);
        if (project == null)
        {
            return NotFound();
        }

        db.Projects.Remove(project);
        db.SaveChanges();

        return StatusCode(HttpStatusCode.NoContent);
    }
    */

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            db.Dispose();
        }
        base.Dispose(disposing);
    }

    private bool ProjectExists(int key)
    {
        return db.Projects.Count(e => e.ProjectID == key) > 0;
    }
}

Esta es la primera vez que uso OData con Database First, por lo que no estoy seguro de qué está causando esto.

Estoy usando los últimos tiempos de ejecución de Nuget en .NET 4.5.2.

Answer 1

De los documentos 13.1 Atributos de límite de modelo :

Ahora la configuración predeterminada para WebAPI OData es: el cliente no puede aplicar $ count, $ orderby, $ select, $ top, $ expand, $ filter en la consulta, query como localhost / odata / Customers? $ Orderby = El nombre fallará como BadRequest, porque todas las propiedades no son clasificables por defecto, esto es un cambio radical en 6.0.0

Por lo tanto, ahora necesitamos habilitar OData Model Bound Attributes, que puede hacer globalmente con la línea media en el siguiente bloque (los otros dos son su código):

ODataModelBuilder builder = new ODataConventionModelBuilder();
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null); //new line
builder.EntitySet<DB.Project>("Projects");

Pero eso es un tipo general y funciona en función de la mejor seguridad / rendimiento que brinda este cambio.

Por lo tanto, puede, y tal vez debería, habilitar los Atributos de límites del modelo de datos usando llamadas de API fluidas por entidad como esta:

builder.EntitySet<DB.Project>("Projects"); //your line of code
builder.EntityType<DB.Project>().Filter("ProjectID");

Esta respuesta debería resolver el problema que publicaste pero, supongo, necesitarás echarle un vistazo a esos documentos para que puedas buscar una solución completa para el resto de tu proyecto (a menos que, por supuesto, solo implementes el -linea atrapa todo!).

Tal como lo sugiere el nombre "Modelo Bound Attribute", también puede lograr lo que necesita a través de atributos en sus modelos, que está cubierto (de hecho, es el foco principal de) los documentos también.

Editar febrero de 2017:

Parece haber un error en la API fluida por entidad. Las llamadas a $expand conjuntos de entidades devuelven de manera intermitente 400 Bad Request con el error en la pregunta original a pesar de que los conjuntos de entidades se configuraron con una API fluida. No sé si este error solo existe en $expand o con otros params de consulta. Tampoco sé si es mi código el que está causando el problema o un error de MS y, por lo tanto, algo que otros están encontrando. Investigaré esto más adelante y actualizaré esta respuesta. Por ahora estoy usando la captura de una sola línea; eso funciona bien

Edición adicional:

Acabo de volver a leer algunos de los documentos (para intentar que esta actualización sea lo más comprensible posible) y parecen dar a entender que tengo configuradas las cosas (con la API Global Config de una sola línea más la API) , la API fluida por entidad seguirá siendo respetada porque:

"Las configuraciones de consulta se pueden ubicar en muchos lugares, con la siguiente precedencia de menor a mayor: Valor predeterminado del sistema (no se puede consultar de manera predeterminada), Configuración global, Atributo del límite de modelo, API Fluent".

Por lo tanto, tal vez esto es lo que tiene que hacer: agregar el one-line-catch-all y luego ajustar con modelos-bound-attributes, con fluidez API o ambos. Necesito probar esto e informaré pronto ...