Custom Type with == Operator

[cyb3rsyph0n]

Is there a way for the rules engine to understand MyType == "" is a valid comparison? My type supports string comparison but when running through the rules engine I simply get Exception while parsing expression workOrder.workOrderStatus == "Draft" - Operator '==' incompatible with operand types 'WorkOrderStatus' and 'String'. I've tried registering the custom type in the reSettings but nothing seems to allow me to use the string comparison.

[abbasc52]

Hi @cyb3rsyph0n can you provide more details on your model?

[cyb3rsyph0n]

Sure,

I have created a "SmartEnum" class which allows me to add additional properties etc. etc. to an "Enum" I use it throughout my code for various reasons but in this case I am using it to track a Work Orders Status called "WorkOrderStatus". Throughout my code using lambdas I can compare with if (workOrder.WorkOrderStatus == "Draft") return null; and it works fine since I've overridden the appropriate methods for a string to "BaseEnum" comparison.

When using it within the RulesEngine though I receive an error that it cannot compare the WorkOrderStatus to a String. I instead have to write workOrder.WorkOrderStatus.ToString() == "Draft" for it to allow the comparison. I tried importing the custom types for WorkOrderStatus but the closest that got me was being able to write workOrder.WorkOrderStatus == WorkOrderStatus.Draft which wasn't ideal either.

Below is my custom Enum Type and the WorkOrderStatus of the type

public abstract class BaseEnum<TType> : IBaseEnum where TType : BaseEnum<TType>
{
    /// <summary>
    ///     Constructor that sets the name and description
    /// </summary>
    /// <param name="name">Required name for base enum</param>
    /// <param name="description">Required description for base enum</param>
    protected BaseEnum(string name, string description)
    {
        Name = name;
        Description = description;
    }

    /// <summary>
    ///     Description of the enum being created
    /// </summary>
    public string Description { get; }

    /// <summary>
    ///     Name of the enum being created
    /// </summary>
    public string Name { get; }

    /// <summary>
    ///     Overrides equals
    /// </summary>
    /// <param name="obj">Required obj to compare to</param>
    /// <returns></returns>
    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;

        if (obj is string) return Name.Equals(obj.ToString(), StringComparison.InvariantCultureIgnoreCase);

        return obj.GetType() == GetType() && Equals((BaseEnum<TType>) obj);
    }

    /// <summary>
    ///     Check equals against a string
    /// </summary>
    /// <param name="value">Required value to check against</param>
    /// <param name="comparisonType">Comparison type</param>
    /// <returns></returns>
    public bool Equals(string value, StringComparison comparisonType = StringComparison.InvariantCultureIgnoreCase)
    {
        return Name.Equals(value, comparisonType);
    }

    /// <summary>
    ///     Looks up an enum of the inherited type by its name
    /// </summary>
    /// <param name="name">name of the enum to look for</param>
    /// <returns>Enum class that has the matching name</returns>
    public static TType FindByName(string name)
    {
        var pList = typeof(TType).GetFields();

        if (string.IsNullOrEmpty(name)) return null;

        foreach (var p in pList)
            if (p.FieldType.IsAssignableFrom(typeof(TType)))
            {
                var b = (IBaseEnum) p.GetValue(null);

                if (b?.Name == name) return (TType) b;
            }

        throw new EnumNotFoundException($"{typeof(TType).Name} does not contain a value for {name}");
    }

    /// <summary>
    ///     Override for GetHashCode
    /// </summary>
    /// <returns></returns>
    public override int GetHashCode()
    {
        return HashCode.Combine(Description, Name);
    }

    /// <summary>
    ///     Override == operator
    /// </summary>
    /// <param name="lhs">Required lhs to compare</param>
    /// <param name="rhs">Required rhs to compare</param>
    /// <returns></returns>
    public static bool operator ==(BaseEnum<TType> lhs, BaseEnum<TType> rhs)
    {
        return rhs?.Name == lhs?.Name && rhs?.Description == lhs?.Description;
    }

    /// <summary>
    ///     Override == operator for comparing strings
    /// </summary>
    /// <param name="lhs">BaseEnum to compare</param>
    /// <param name="rhs">string name to compare against</param>
    /// <returns></returns>
    public static bool operator ==(BaseEnum<TType> lhs, string rhs)
    {
        return string.Equals(lhs?.Name, rhs, StringComparison.CurrentCultureIgnoreCase);
    }

    /// <summary>
    ///     Implicit conversion for string to BaseEnum
    /// </summary>
    /// <param name="s">Required name to convert from</param>
    /// <returns></returns>
    public static implicit operator BaseEnum<TType>(string s)
    {
        Verify.NotNull(s, nameof(s));
        return FindByName(s);
    }

    /// <summary>
    ///     Override != operator for comparing string
    /// </summary>
    /// <param name="lhs">BaseEnum to compare</param>
    /// <param name="rhs">string name to compare against</param>
    /// <returns></returns>
    public static bool operator !=(BaseEnum<TType> lhs, string rhs)
    {
        return !string.Equals(lhs?.Name, rhs, StringComparison.CurrentCultureIgnoreCase);
    }

    /// <summary>
    ///     Override != operator
    /// </summary>
    /// <param name="lhs">Required lhs to compare</param>
    /// <param name="rhs">Required rhs to compare</param>
    /// <returns></returns>
    public static bool operator !=(BaseEnum<TType> lhs, BaseEnum<TType> rhs)
    {
        return !(lhs == rhs);
    }

    /// <summary>
    ///     Return properties as a key value pair
    /// </summary>
    /// <returns></returns>
    public virtual Dictionary<string, string> ToDictionary()
    {
        return new Dictionary<string, string> { { "Value", Name }, { "Text", Description } };
    }

    /// <summary>
    ///     Returns the Description of the enum created
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return Description;
    }

    /// <summary>
    ///     Override equals
    /// </summary>
    /// <param name="other">Required base enum to compare to</param>
    /// <returns></returns>
    private bool Equals(IBaseEnum other)
    {
        return Description == other.Description && Name == other.Name;
    }

    /// <inheritdoc />
    IBaseEnum IBaseEnum.FindByName(string name)
    {
        return FindByName(name);
    }
}

public class WorkOrderStatus : BaseEnum<WorkOrderStatus>
{
    /// <summary>
    ///     Draft status
    /// </summary>
    public static readonly WorkOrderStatus Draft = new(nameof(Draft), nameof(Draft));

    /// <summary>
    ///     Order received
    /// </summary>
    public static readonly WorkOrderStatus OrderReceived = new(
        nameof(OrderReceived),
        nameof(OrderReceived).SpacesInsteadOfPascalCase()
    );

    /// <inheritdoc />
    private WorkOrderStatus(string name, string description)
        : base(name, description)
    {
    }

    /// <summary>
    ///     Default work order status
    /// </summary>
    public static WorkOrderStatus DefaultWorkOrderStatus => Draft;
}