Exclut les biens de WebApi OData (EF) réponse en c#

Je suis un peu en retard pour le sujet, mais je pense que cela pourrait vous aider.

Je suppose que vous souhaitez crypter le mot de passe à des fins de stockage. Avez-vous regardé à l'aide d'un odata d'action pour définir le mot de passe? À l'aide d'une action permet d'ignorer la propriété de mot de passe lors de la configuration de votre entités pendant encore d'exposer une méthode propre à l'utilisateur final pour mettre à jour le mot de passe.

première: ignorer le mot de passe de propriété

builder.EntitySet<UserInfo>("UserInfo").EntityType.Ignore(ui => ui.Password);

deuxième: ajouter votre odata action

builder.EntityType<UserInfo>().Action("SetPassword").Returns<IHttpActionResult>();

Puis ajouter la méthode SetPassword à votre UserInfoController.

OriginalL'auteur Rick Willis

Il pourrait être un peu tard, mais une solution élégante serait d'ajouter des QueryableSelectAttribute et puis tout simplement la liste des champs que vous souhaitez utiliser sur le service-côté. Dans votre cas, il va ressembler à quelque chose comme ceci:

public class QueryableSelectAttribute : ActionFilterAttribute
{
    private const string ODataSelectOption = "$select=";
    private string selectValue;

    public QueryableSelectAttribute(string select)
    {
        this.selectValue = select;
    }

    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        base.OnActionExecuting(actionContext);

        var request = actionContext.Request;
        var query = request.RequestUri.Query.Substring(1);
        var parts = query.Split('&').ToList();

        for (int i = 0; i < parts.Count; i++)
        {
            string segment = parts[i];
            if (segment.StartsWith(ODataSelectOption, StringComparison.Ordinal))
            {
                parts.Remove(segment);
                break;
            }
        }

        parts.Add(ODataSelectOption + this.selectValue);

        var modifiedRequestUri = new UriBuilder(request.RequestUri);
        modifiedRequestUri.Query = string.Join("&", parts.Where(p => p.Length > 0));
        request.RequestUri = modifiedRequestUri.Uri;

        base.OnActionExecuting(actionContext);
    }
}

Et dans le contrôleur, il suffit d'ajouter l'attribut avec les propriétés souhaitées:

[EnableQuery]
[QueryableSelect("Name,LastName,Email")]
public IQueryable<User> GetUsers()
{
    return db.Users;
}

Et c'est tout!

Bien sûr, le même principe peut être appliqué pour un custom QueryableExpandAttribute.

OriginalL'auteur Corneliu Serediuc

Ce que vous devez faire est de faire un odata contrôleur qui renvoie prévu un sous-ensemble de l'entité d'origine.

//in WebApi Config Method
config.MapHttpAttributeRoutes();

ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<FullEntity>("FullData");
builder.EntitySet<SubsetEntity>("SubsetData");
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());


config.Routes.MapHttpRoute(
  name: "DefaultApi",
  routeTemplate: "api/{controller}/{action}/{id}",
  defaults: new { id = RouteParameter.Optional, action = "GET" }
);
SetupJsonFormatters();
config.Filters.Add(new UncaughtErrorHandlingFilterAttribute());

... alors les deux Odata Contrôleurs de un pour FulLData, un pour SubsetData (sécurité différents),

namespace myapp.Web.OData.Controllers
{
    public class SubsetDataController : ODataController
    {
        private readonly IWarehouseRepository<FullEntity> _fullRepository;
        private readonly IUserRepository _userRepository;

        public SubsetDataController(
            IWarehouseRepository<fullEntity> fullRepository,
            IUserRepository userRepository
            )
        {
            _fullRepository = fullRepository;
            _userRepository = userRepository;
        }

public IQueryable<SubsetEntity> Get()
        {
            Object webHostHttpRequestContext = Request.Properties["MS_RequestContext"];
            System.Security.Claims.ClaimsPrincipal principal =
                (System.Security.Claims.ClaimsPrincipal)
                    webHostHttpRequestContext.GetType()
                        .GetProperty("Principal")
                        .GetValue(webHostHttpRequestContext, null);
            if (!principal.Identity.IsAuthenticated)
                throw new Exception("user is not authenticated cannot perform OData query");

            //do security in here

            //irrelevant but this just allows use of data by Word and Excel.
            if (Request.Headers.Accept.Count == 0)
                Request.Headers.Add("Accept", "application/atom+xml");

            return _fullRepository.Query().Select( b=>
                    new SubsetDataListEntity
                    {
                        Id = b.Id,
                        bitofData = b.bitofData
                    }
          } //end of query
   } //end of class

OriginalL'auteur

Nous pouvons profiter de la ConventionModelBuilder et l'utilisation DataContract/DataMember pour activer explicitement les propriétés d'être dans le EdmModel.

DataContract & DataMember

Règle: Si vous utilisez DataContract ou DataMember, seulement de la propriété avec [DataMember] attribut sera ajouté dans Edm modèle.

Noter que cela n'affecte pas la EntityFramework, car nous ne sommes pas à l'aide de la [NotMapped] attribut (sauf si vous ne voulez pas qu'il en soit le modèle)

[DataContract]
public class User
{
    [DataMember]
    public int Id { get; set; }

    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public string Email { get; set; }

    [DataMember]
    public string LastName {get; set; }

    //NB Password won't be in EdmModel but still available to EF
    public string Password {get; set;}
}

Cela a l'avantage de garder toute la logique de mapping dans un endroit dans votre projet

OriginalL'auteur Paul Hatcher

Vous pouvez créer une nouvelle vue dans la DB avec les seules données dont vous avez besoin. Puis définissez EntitySetRights.Aucune pour la table des Utilisateurs et de créer des relations nécessaires pour créé vue.
Maintenant, vous pouvez faire commun odata requêtes (GET odata/UsersFromView) et d'utilisateurs de données sans mot de passe. Post de demande que vous pouvez faire à l'aide de table des Utilisateurs.

OriginalL'auteur DominGez

Vous ne devriez pas interroger votre modèle de Domaine directement dans le contrôleur. Au lieu de cela, créer un QueryModel DTO que des cartes pour le modèle de Domaine.

Vous pouvez lire plus au sujet de ces concepts dans le DDD et le CQRS

OriginalL'auteur LastTribunal