private RedisKey FilterToKey(Filter filter)
{
var member = _typeDefinition.IndexedFields.Where(f => f.Name == filter.OperandName).FirstOrDefault();
if (member == null)
{
throw new InvalidFilterExpression($"{filter.OperandName} is not indexed");
}
RedisValue value;
if (member.Type.GetTypeInfo().IsEnum)
{
value = _valueConverter.FromObject(Enum.ToObject(member.Type, (int)filter.RightValue), member.Type);
}
else
{
value = _valueConverter.FromObject(filter.RightValue, member.Type);
}
if (filter.Operator == FilterOperator.NotEquals)
{
if (member.Type != typeof(bool))
{
throw new InvalidFilterExpression($"The 'Not Equals' operation is only supported on booleans.");
}
value = !(bool)value;
}
return(_storageKeyGenerator.GetFieldIndexKey(_typeDefinition, member, value));
}
public List <HashEntry> HashFor <T>(ITypeDefinition <T> definition, T instance, bool isNew, HashEntry[] existingRecord)
{
// make a check for indexed fields that are ignored
var changedList = new List <HashEntry>();
foreach (var field in definition.AllFields)
{
if (isNew && definition.IgnoreOnCreateFields.Any(f => f.Name == field.Name))
{
continue;
}
else if (!isNew && definition.IgnoreOnUpdateFields.Any(f => f.Name == field.Name))
{
continue;
}
var value = definition.Accessor[instance, field.Name];
var redisValue = _redisValueConverter.FromObject(value, field.Type);
if (definition.RequiredFields.Any(f => f.Name == field.Name) && !redisValue.HasValue)
{
throw new FieldRequiredException(field);
}
if (definition.IndexedFields.Contains(field) || redisValue != existingRecord.FirstOrDefault(h => h.Name == field.Name).Value)
{
changedList.Add(new HashEntry(definition.GetHashName(field), redisValue));
}
}
return(changedList);
}
