Skip to content

Instantly share code, notes, and snippets.

@alaawahbah

alaawahbah/dynamic read models.cs

Last active July 13, 2020 13:03
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save alaawahbah/f5992a0a1dc2e9626bfc93a46ec95183 to your computer and use it in GitHub Desktop.
Save alaawahbah/f5992a0a1dc2e9626bfc93a46ec95183 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
dynamic read models.cs
using INTDV.BASECLASSES.BaseRepository;
using INTDV.BASECLASSES.Shared;
using INTDV.COMMUNICO.BACKEND.Core.Entities;
using INTDV.COMMUNICO.BACKEND.Core.Filters;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading.Tasks;
using Z.EntityFramework.Plus;
namespace INTDV.COMMUNICO.BACKEND.EntityFramework
{
public class CommunicoContext : DbContext, IBaseContext
{
private readonly ActiveContext _activeContext;
public CommunicoContext(DbContextOptions<CommunicoContext> options, ActiveContext activeContext) : base(options)
{
_activeContext = activeContext;
//this.Database.EnsureCreated();
foreach (var EntityType in Model.GetEntityTypes())
{
this.Filter<Users>(Filters.SoftDelete, t => t.Where(t => !t.IsDeleted), true);
}
var companyIds = _activeContext.CompanyIds;
this.Filter<Users>(Filters.UserCompanies, t => t.Where(t => t.UsersCompanies.Any(b => companyIds.Contains(b.CompanyId))), false);
if (companyIds != null && companyIds.Count > 0)
FilterEnable(Filters.UserCompanies);
}
private bool FilterExists(object filterName)
{
try
{
var filter = this.Filter(filterName).GetFilter();
if (filter != null)
return true;
return false;
}
catch (Exception)
{
return false;
}
}
private void FilterDisable(object filterName)
{
try
{
if (FilterExists(filterName))
this.Filter(filterName).Disable();
}
catch (Exception)
{
}
}
private void FilterEnable(object filterName)
{
try
{
if (FilterExists(filterName))
this.Filter(filterName).Enable();
}
catch (Exception)
{
}
}
public virtual DbSet<Companies> Companies { get; set; }
public virtual DbSet<Bots> Bots { get; set; }
public virtual DbSet<Screens> Screens { get; set; }
public virtual DbSet<Files> Files { get; set; }
public virtual DbSet<Users> Users { get; set; }
public virtual DbSet<Robots> Robots { get; set; }
public virtual DbSet<RobotTypes> RobotTypes { get; set; }
public virtual DbSet<UsersCompanies> UsersCompanies { get; set; }
public virtual DbSet<RobotAnimations> RobotAnimations { get; set; }
public virtual DbSet<RobotBehaviors> RobotBehaviors { get; set; }
public virtual DbSet<RobotPredefinedSounds> RobotPredefinedSounds { get; set; }
public virtual DbSet<Languages> Languages { get; set; }
public virtual DbSet<BotLanguages> BotLanguages { get; set; }
public virtual DbSet<Templates> Templates { get; set; }
public virtual DbSet<HeaderTempelates> HeaderTempelates { get; set; }
public virtual DbSet<UILanguages> UILanguages { get; set; }
public virtual DbSet<Entities> Entities { get; set; }
public virtual DbSet<EntityTypes> EntityTypes { get; set; }
public virtual DbSet<EntityValueLanguages> EntityValueLanguages { get; set; }
public virtual DbSet<EntityValueLanguageSynonyms> EntityValueLanguageSynonyms { get; set; }
public virtual DbSet<EntityValues> EntityValues { get; set; }
public virtual DbSet<IntentCategories> IntentCategories { get; set; }
public virtual DbSet<Intents> Intents { get; set; }
public virtual DbSet<IntentExamples> IntentExamples { get; set; }
public virtual DbSet<Zones> Zones { get; set; }
public virtual DbSet<BotZones> BotZones { get; set; }
public virtual DbSet<Domains> Domains { get; set; }
public virtual DbSet<KnowledgeBases> KnowledgeBases { get; set; }
public virtual DbSet<KnowledgeBasesBots> KnowledgeBasesBots { get; set; }
public virtual DbSet<QuestionsAndAnswersGroups> QuestionsAndAnswersGroups { get; set; }
public virtual DbSet<QAGroupUserQuestions> QAGroupUserQuestions { get; set; }
public virtual DbSet<QAGroupRobotInitiatePhrases> QAGroupRobotInitiatePhrases { get; set; }
public virtual DbSet<QAGroupRobotAnswers> QAGroupRobotAnswers { get; set; }
public virtual DbSet<KnowledgeBasesLanguages> KnowledgeBasesLanguages { get; set; }
public virtual DbSet<Roles> Roles { get; set; }
public virtual DbSet<UsersRoles> UsersRoles { get; set; }
public virtual DbSet<RolesPermissions> RolesPermissions { get; set; }
public virtual DbSet<Permissions> Permissions { get; set; }
public virtual DbSet<UserFormData> UserFormData { get; set; }
public virtual DbSet<UserFormDataField> UserFormDataFields { get; set; }
public virtual DbSet<Printer> Printers { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Bots>().HasQueryFilter(f => !f.IsDeleted);
//var userCompany = new List<long> { 5 };
//foreach (var entityType in modelBuilder.Model.GetEntityTypes())
//{
// ConfigureGlobalFiltersMethodInfo
// .MakeGenericMethod(entityType.ClrType)
// .Invoke(this, new object[] { modelBuilder, entityType });
//}
//if (_activeContext.CompanyIds?.Any() ?? false)
//{
// modelBuilder.Entity<Companies>().HasQueryFilter(f => !f.IsDeleted && userCompany.Contains(f.Id));
// modelBuilder.Entity<Bots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Screens>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Files>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Users>().HasQueryFilter(f => !f.IsDeleted && f.UsersCompanies.Any(b => userCompany.Contains(b.CompanyId)));
// modelBuilder.Entity<Robots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotTypes>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UsersCompanies>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotAnimations>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotBehaviors>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Languages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<BotLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Templates>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<HeaderTempelates>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UILanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Domains>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Zones>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<BotZones>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Intents>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<IntentCategories>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<IntentExamples>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Entities>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityTypes>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValues>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValueLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValueLanguageSynonyms>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBases>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesBots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QuestionsAndAnswersGroups>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupUserQuestions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupRobotInitiatePhrases>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupRobotAnswers>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotPredefinedSounds>()
// .HasQueryFilter(f => !f.IsDeleted)
// .Property(p => p.FileSize).HasColumnType("decimal(18,2)");
// modelBuilder.Entity<Roles>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UsersRoles>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RolesPermissions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Permissions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UserFormData>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UserFormDataField>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Printer>().HasQueryFilter(f => !f.IsDeleted);
//}
//else
//{
// modelBuilder.Entity<Companies>().HasQueryFilter(f => !f.IsDeleted && userCompany.Contains(f.Id));
// modelBuilder.Entity<Bots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Screens>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Files>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Users>().HasQueryFilter(f => !f.IsDeleted && f.UsersCompanies.Any(b => userCompany.Contains(b.CompanyId)));
// modelBuilder.Entity<Robots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotTypes>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UsersCompanies>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotAnimations>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotBehaviors>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Languages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<BotLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Templates>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<HeaderTempelates>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UILanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Domains>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Zones>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<BotZones>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Intents>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<IntentCategories>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<IntentExamples>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Entities>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityTypes>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValues>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValueLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<EntityValueLanguageSynonyms>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBases>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesBots>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<KnowledgeBasesLanguages>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QuestionsAndAnswersGroups>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupUserQuestions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupRobotInitiatePhrases>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<QAGroupRobotAnswers>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RobotPredefinedSounds>()
// .HasQueryFilter(f => !f.IsDeleted)
// .Property(p => p.FileSize).HasColumnType("decimal(18,2)");
// modelBuilder.Entity<Roles>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UsersRoles>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<RolesPermissions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Permissions>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UserFormData>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<UserFormDataField>().HasQueryFilter(f => !f.IsDeleted);
// modelBuilder.Entity<Printer>().HasQueryFilter(f => !f.IsDeleted);
//}
}
public async Task<int> CommitAsync()
{
return await SaveChangesAsync();
}
///////////////////////
///
private static MethodInfo ConfigureGlobalFiltersMethodInfo = typeof(CommunicoContext).GetMethod(nameof(ConfigureGlobalFilters), BindingFlags.Instance | BindingFlags.NonPublic);
private bool IsSoftDeleteFilterEnabled = true;
private bool IscompanyDataFilterEnabled = true;
protected virtual Expression<Func<TEntity, bool>> CreateFilterExpression<TEntity>()
where TEntity : class
{
Expression<Func<TEntity, bool>> expression = null;
if (typeof(TEntity).BaseType.IsEquivalentTo(typeof(BaseEntity<long>)))
{
Expression<Func<TEntity, bool>> softDeleteFilter;
Type generic = typeof(TEntity).BaseType.GetGenericArguments().FirstOrDefault();
if (generic != null && generic == typeof(long))
{
softDeleteFilter = e => !IsSoftDeleteFilterEnabled || !EF.Property<bool>(e, "IsDeleted");
expression = expression == null ? softDeleteFilter : CombineExpressions(expression, softDeleteFilter);
}
}
if (typeof(TEntity).IsEquivalentTo(typeof(Users)) && _activeContext.UserId.HasValue)
{
Expression<Func<TEntity, bool>> companyDataFilter;
//softDeleteFilter = e => !IsSoftDeleteFilterEnabled || !((BaseEntity<long>)(object)e).IsDeleted;
var companyIds = _activeContext.CompanyIds;
companyDataFilter = e => !IscompanyDataFilterEnabled || ((companyIds != null && companyIds.Count > 0) ? EF.Property<ICollection<UsersCompanies>>(e, "UsersCompanies").Any(b => companyIds.Contains(b.CompanyId)) : false);
expression = expression == null ? companyDataFilter : CombineExpressions(expression, companyDataFilter);
}
return expression;
}
protected virtual Expression<Func<T, bool>> CombineExpressions<T>(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
{
return ExpressionCombiner.Combine(expression1, expression2);
}
internal static class ExpressionCombiner
{
public static Expression<Func<T, bool>> Combine<T>(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
{
if (expression1 == null && expression2 == null)
{
return null;
}
if (expression1 == null)
{
return expression2;
}
if (expression2 == null)
{
return expression1;
}
var parameter = Expression.Parameter(typeof(T));
var leftVisitor = new ReplaceExpressionVisitor(expression1.Parameters[0], parameter);
var left = leftVisitor.Visit(expression1.Body);
var rightVisitor = new ReplaceExpressionVisitor(expression2.Parameters[0], parameter);
var right = rightVisitor.Visit(expression2.Body);
return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(left, right), parameter);
}
class ReplaceExpressionVisitor : ExpressionVisitor
{
private readonly Expression _oldValue;
private readonly Expression _newValue;
public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
{
_oldValue = oldValue;
_newValue = newValue;
}
public override Expression Visit(Expression node)
{
if (node == _oldValue)
{
return _newValue;
}
return base.Visit(node);
}
}
}
protected void ConfigureGlobalFilters<TEntity>(ModelBuilder modelBuilder, IMutableEntityType entityType)
where TEntity : class
{
if (entityType.BaseType == null && ShouldFilterEntity<TEntity>(entityType))
{
var filterExpression = CreateFilterExpression<TEntity>();
if (filterExpression != null)
{
if (entityType.IsKeyless)
{
modelBuilder.Entity<TEntity>().HasQueryFilter(filterExpression);
}
else
{
modelBuilder.Entity<TEntity>().HasQueryFilter(filterExpression);
}
}
}
}
protected virtual bool ShouldFilterEntity<TEntity>(IMutableEntityType entityType) where TEntity : class
{
if (typeof(BaseEntity<long>).IsAssignableFrom(typeof(TEntity)))
{
return true;
}
//if (typeof(TEntity).BaseType.IsEquivalentTo(typeof(BaseEntity<long>)))
//{
// return true;
//}
//if (typeof(IMayHaveTenant).IsAssignableFrom(typeof(TEntity)))
//{
// return true;
//}
//if (typeof(IMustHaveTenant).IsAssignableFrom(typeof(TEntity)))
//{
// return true;
//}
return false;
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment