public static async Task <RepositoryResponse <PaginationModel <TView> > > GetListPostByAdditionalField <TView>(
string fieldName, object fieldValue, string culture, MixDataType dataType
, MixCompareOperatorKind filterType = MixCompareOperatorKind.Equal
, string orderByPropertyName = null, Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Asc, int?pageSize = null, int?pageIndex = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
{
PageIndex = pageIndex.HasValue ? pageIndex.Value : 0,
PageSize = pageSize
}
};
// Get Value Predicate By Type
Expression <Func <MixAttributeSetValue, bool> > valPredicate = m => m.AttributeSetName == MixConstants.AttributeSetName.ADDITIONAL_FIELD_POST &&
m.AttributeFieldName == fieldName;
var pre = GetValuePredicate(fieldValue.ToString(), filterType, dataType);
if (pre != null)
{
valPredicate = valPredicate.AndAlso(pre);
}
var query = context.MixAttributeSetValue.Where(valPredicate).Select(m => m.DataId).Distinct();
var dataIds = query.ToList();
var relatedQuery = context.MixRelatedAttributeData.Where(
m => m.ParentType == MixDatabaseParentType.Post && m.Specificulture == culture &&
dataIds.Any(d => d == m.DataId));
var postIds = relatedQuery.Select(m => int.Parse(m.ParentId)).Distinct().AsEnumerable().ToList();
result = await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetModelListByAsync(
m => m.Specificulture == culture && postIds.Any(p => p == m.Id)
, orderByPropertyName, direction
, pageSize ?? 100, pageIndex ?? 0
, null, null
, context, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
context.Dispose();
}
}
}
public static FunctionModel Create(MixCompareOperatorKind rule, string fieldName, string value)
{
return(new FunctionModel()
{
Rule = rule,
FieldName = fieldName,
Value = value,
});
}
public static FunctionModel Create(MixCompareOperatorKind operatorKind, string fieldName,
string minValue = "", string maxValue = "")
{
return(new FunctionModel()
{
Rule = operatorKind,
FieldName = fieldName,
MinValue = minValue,
MaxValue = maxValue,
});
}
private static string GetQueryString(string columnName, MixCompareOperatorKind kind, params string[] value)
{
return(kind switch
{
MixCompareOperatorKind.Equal => $"{columnName} = '{value[0]}'",
MixCompareOperatorKind.NotEqual => $"{columnName} != '{value[0]}'",
MixCompareOperatorKind.GreaterThanOrEqual => $"{columnName} >= '{value[0]}'",
MixCompareOperatorKind.GreaterThan => $"{columnName} > '{value[0]}'",
MixCompareOperatorKind.LessThanOrEqual => $"{columnName} <= '{value[0]}'",
MixCompareOperatorKind.LessThan => $"{columnName} < '{value[0]}'",
MixCompareOperatorKind.Contain => $"{columnName} LIKE '%{value[0]}%'",
MixCompareOperatorKind.NotContain => $"{columnName} NOT LIKE '%{value[0]}%'",
MixCompareOperatorKind.InRange => $"{columnName} IN ({string.Join(",", value)})",
MixCompareOperatorKind.NotInRange => $"{columnName} NOT IN ({string.Join(",", value)})",
_ => string.Empty,
});
public static Expression <Func <TModel, bool> > FilterObjectSet <TModel, T>(string propName, T data2, MixCompareOperatorKind filterType)
{
Type type = typeof(TModel);
var par = Expression.Parameter(type, "model");
Type fieldPropertyType;
Expression fieldPropertyExpression;
FieldInfo fieldInfo = type.GetField(propName);
if (fieldInfo == null)
{
PropertyInfo propertyInfo = type.GetProperty(propName);
if (propertyInfo == null)
{
throw new Exception();
}
fieldPropertyType = propertyInfo.PropertyType;
fieldPropertyExpression = Expression.Property(par, propertyInfo);
}
else
{
fieldPropertyType = fieldInfo.FieldType;
fieldPropertyExpression = Expression.Field(par, fieldInfo);
}
BinaryExpression eq = null;
switch (filterType)
{
case MixCompareOperatorKind.Equal:
eq = Expression.Equal(fieldPropertyExpression,
Expression.Constant(data2, fieldPropertyType));
break;
case MixCompareOperatorKind.LessThan:
eq = Expression.LessThan(fieldPropertyExpression,
Expression.Constant(data2, fieldPropertyType));
break;
case MixCompareOperatorKind.GreaterThan:
eq = Expression.GreaterThan(fieldPropertyExpression,
Expression.Constant(data2, fieldPropertyType));
break;
case MixCompareOperatorKind.LessThanOrEqual:
eq = Expression.LessThanOrEqual(fieldPropertyExpression,
Expression.Constant(data2, fieldPropertyType));
break;
case MixCompareOperatorKind.GreaterThanOrEqual:
eq = Expression.GreaterThanOrEqual(fieldPropertyExpression,
Expression.Constant(data2, fieldPropertyType));
break;
case MixCompareOperatorKind.InRange:
var method = typeof(string).GetMethod("Contains");
var call = Expression.Call(par, method, Expression.Constant(data2, typeof(string)));
return(Expression.Lambda <Func <TModel, bool> >(call, par));
default:
break;
}
return(Expression.Lambda <Func <TModel, bool> >(eq, par));
}
private static Expression <Func <MixAttributeSetValue, bool> > GetValuePredicate(string fieldValue
, MixCompareOperatorKind filterType, MixDataType dataType)
{
Expression <Func <MixAttributeSetValue, bool> > valPredicate = null;
switch (dataType)
{
case MixDataType.Date:
case MixDataType.Time:
if (DateTime.TryParse(fieldValue, out DateTime dtValue))
{
valPredicate = FilterObjectSet <MixAttributeSetValue, DateTime>("DateTimeValue", dtValue, filterType);
}
break;
case MixDataType.Double:
if (double.TryParse(fieldValue, out double dbValue))
{
valPredicate = FilterObjectSet <MixAttributeSetValue, double>("DoubleValue", dbValue, filterType);
}
break;
case MixDataType.Boolean:
if (bool.TryParse(fieldValue, out bool boolValue))
{
valPredicate = FilterObjectSet <MixAttributeSetValue, bool>("BooleanValue", boolValue, filterType);
}
break;
case MixDataType.Integer:
if (int.TryParse(fieldValue, out int intValue))
{
valPredicate = FilterObjectSet <MixAttributeSetValue, int>("IntegerValue", intValue, filterType);
}
break;
case MixDataType.Reference:
break;
case MixDataType.Duration:
case MixDataType.Custom:
case MixDataType.DateTime:
case MixDataType.PhoneNumber:
case MixDataType.Text:
case MixDataType.Html:
case MixDataType.MultilineText:
case MixDataType.EmailAddress:
case MixDataType.Password:
case MixDataType.Url:
case MixDataType.ImageUrl:
case MixDataType.CreditCard:
case MixDataType.PostalCode:
case MixDataType.Upload:
case MixDataType.Color:
case MixDataType.Icon:
case MixDataType.VideoYoutube:
case MixDataType.TuiEditor:
case MixDataType.QRCode:
default:
valPredicate = FilterObjectSet <MixAttributeSetValue, string>("StringValue", fieldValue, filterType);
break;
}
return(valPredicate);
}
