Scheduling Rules and Complexity in Coding Lots of rules respect to time?

Question

We have some fields (age, visit type, insurance type, city) and some rules:

1. Some doctors that define weekly schedule template like as:

Doctor D1 works on Monday 7-9 pm , Thursday 7-9 pm.

2. Some type of Visit Type like as:

Doctor D1 accept Follow up- Laser- Rhinoplasty.

3. Some type of counters rule in specific time range for doctor:

Doctor D1 accept only 50 patient with insurance type A in 18 to 30 April.

4. Some type of specific rule:

D1 Accept patient for laser type on Mondays

or for example:

D1 Accept patient only 15-aged patient from New York city

My question is what is the best way for handling this combination of rule for provider (medical) scheduling? (I should combine 4 with 2 in Defining Visit Type form, or maybe firs should define working hour template (1) in one form and then mixing (2, 3, 4) and then add to working hour template?

How I can handle this complex situation for rule based Online appointment booking? I means patient with 16 years not seen time slot that has rule for 15-years patient.

My goal is very simple. just any patient that satisfy rules (that defined in time slots by provider) can see correspond time slot, not all time slots. for reaching to this goal how I can handle this rules (which orders)?

Answer 1

Business rules engines allow you to specify your conditions in a (more or less) ad-hoc manner.

Below is an example. Note that this is code, so if your rules must be fluid, you would need a script execution engine to run them.

public class PreferredCustomerDiscountRule : Rule
{
    public override void Define()
    {
        Customer customer = null;
        IEnumerable<Order> orders = null;

        When()
            .Match<Customer>(() => customer, c => c.IsPreferred)
            .Query(() => orders, x => x
                .Match<Order>(
                    o => o.Customer == customer,
                    o => o.IsOpen,
                    o => !o.IsDiscounted)
                .Collect()
                .Where(c => c.Any()));

        Then()
            .Do(ctx => ApplyDiscount(orders, 10.0))
            .Do(ctx => ctx.UpdateAll(orders));
    }

    private static void ApplyDiscount(IEnumerable<Order> orders, double discount)
    {
        foreach (var order in orders)
        {
            order.ApplyDiscount(discount);
        }
    }
}

If you don't feel like writing code for your rules, or need the flexibility of storing them as data, not code, you can use an engine that serializes the rules in JSON or XML, like the MicroRule Engine.