Lassen Sie Benutzer nur ihren eigenen Inhalt bearbeiten/löschen (in generischen Repositories)

Question

Ich möchte Benutzer nur ihren eigenen Inhalt verwalten lassen (bearbeiten/löschen/Liste der Dinge ... und alles muss Admin-Panel für ihren eigenen Inhalt). In meinem Projekt verwende ich unitOfwork und GenericRepositories und ich habe BaseRepository für die Implementierung der Rest der Repositories (um doppelte Codes zu vermeiden); Ich weiß, ich muss Benutzerrepository implementieren und es in anderen Repositories verwenden, um Benutzer zu erhalten und die Operation fortzusetzen ..., aber ich möchte wissen, ob es einen Weg gibt, BaseRepository zu implementieren? oder eine andere Möglichkeit, die Manipulation von Repositories und das Schreiben von doppeltem Code zu vermeiden?

namespace ServiceLayer.Repository 
{ 
    public abstract class BaseRepository<T> : IBaseRepository<T> where T : BaseModel 
    { 
     private readonly IDbSet<T> _t; 
     private readonly IUnitOfWork _unitOfWork; 
     private IQueryable<T> _db; 
     protected BaseRepository(IUnitOfWork unitOfWork) 
     { 
      _unitOfWork = unitOfWork; 
      _t = _unitOfWork.Set<T>(); 
      _db = _t; 
     } 
     public virtual (IQueryable<T> List, int? PageId, int? PageCount) GetAll(int? pageId, Expression<Func<T, bool>>[] searchExpression, params Expression<Func<T, object>>[] includeExpressions) 
     { 


      if (includeExpressions != null && includeExpressions.Any()) 
      { 
       foreach (var expression in includeExpressions) 
       { 
        _db = _db.Include(expression); 
       } 
      } 
      if (searchExpression != null && searchExpression.Any()) 
      { 
       foreach (var expression in searchExpression) 
       { 
        _db = _db.Where(expression); 
       } 
      } 

      if (pageId == null) return (_db, null, null); 

      if (pageId <= 0) 
       pageId = 1; 

      int take = 5; 
      int skip = ((int)pageId - 1) * take; 
      int count = _db.Count(); 
      int pageCount = count/take; 



      var list = _db.OrderByDescending(x => x.Id).Skip(skip).Take(take); 
      return (list, (int)pageId, pageCount); 
     } 


     public virtual T Get(long id, params Expression<Func<T, object>>[] includeExpression) 
     { 
      if (includeExpression == null) return _t.Find(id); 

      foreach (var expression in includeExpression) 
      { 
       _db = _db.Include(expression); 
      } 
      return _db.SingleOrDefault(x => x.Id == id); 
     } 

     public virtual List<T> GetIdsArray(long?[] ids, params Expression<Func<T, object>>[] includeExpression) 
     { 
      if (ids == null) return null; 
      if (includeExpression == null) return _t.Where(x => ids.Contains(x.Id)).ToList(); 
      foreach (var expression in includeExpression) 
      { 
       _db = _db.Include(expression); 
      } 
      return _db.Where(x => ids.Contains(x.Id)).ToList(); 
     } 

     public virtual T Update(T obj) 
     { 
      _unitOfWork.MarkAsChanged(obj); 
      _unitOfWork.SaveAllChanges(); 
      return obj; 
     } 

     public virtual T Add(T obj) 
     { 
      _t.Add(obj); 
      _unitOfWork.SaveAllChanges(); 
      return obj; 
     } 

     public virtual int Remove(T obj) 
     { 
      _t.Remove(obj); 
      return _unitOfWork.SaveAllChanges(); 
     } 

     public virtual int RemoveIdsArray(long?[] objs) 
     { 
      if (objs == null || objs.Length <= 0) return -5; 
      var objects = GetIdsArray(objs, null); 
      foreach (var o in objects) 
      { 
       _t.Remove(o); 
      } 
      return _unitOfWork.SaveAllChanges(); 
     } 


     public virtual (string[] fieldName, IEnumerable<string> DisplayAttribute) GetAllNameAndTitleOfDbTable() 
     { 
      var fieldName = typeof(T).GetProperties(BindingFlags.DeclaredOnly | 
                BindingFlags.Public | 
                BindingFlags.Instance) 
       .Select(property => property.Name) 
       .ToArray(); 
      var name = typeof(T).GetProperties(BindingFlags.DeclaredOnly | 
               BindingFlags.Public | 
               BindingFlags.Instance).Select(property => 
       ((DisplayAttribute)property.GetCustomAttributes(typeof(DisplayAttribute), false).FirstOrDefault()) 
       ?.Name).ToArray(); 
      return (fieldName, name); 
     } 
    } 
} 

Answer 1

Ich glaube, ich verstehe, was Sie erreichen wollen.

Etwas, das ich in der Vergangenheit getan haben ist eine IOwnedEntity Schnittstelle

public interface IOwnedEntity 
{ 
    string EntityOwner { get; set; } 
} 

, die durch meine Modelle umgesetzt wird dann zu erstellen.

public string EntityOwner 
{ 
    get { return Owner; } 
    set { Owner = value; } 
} 

Dann in Ihrem Repository können Sie prüfen, ob T gehört und filtern dementsprechend

private bool EntityIsOwnedByOwner(T entity) 
{ 
    return (entity as IOwnedEntity).EntityOwner == CurrentLoggedOnUserID; 
} 

Offensichtlich wird dies alles braucht ein wenig Arbeit in Ihrem Beispiel zu bekommen funktioniert, aber der Ansatz sollte gesund sein .