kodraus / cirrus Goto Github PK

Adjust the Process type definition as follows:

public class Process<TCommand1, TIn1, TOut1, TCommand2, TIn2, TOut2> : Process<TIn1, TOut1, TIn2, TOut2>, IProcess, IProcessStep<TIn1, TOut2>
        where TCommnd1: IProcessStep<TIn1, TOut1>
        where TIn1 : class, IProcessInput
        where TOut1 : class, IProcessOutput
        where TCommnd2: IProcessStep<TIn2, TOut2>
        where TIn2 : class, IProcessInput
        where TOut2 : class, IProcessOutput

So that we can specify the type of the command to handle the process steps, rather than just specifying the input and output args

Rather than using Func<> for the threads in Process, use Expression<Func<>> instead and compile when necessary to run. This is so we can serialize the expression and pass along to another node to compile and execute

The current Product definition is pretty nasty. This needs to be tidied up as follows:

• Remove IProduct, leave property relationships between Product and Variant as coincidental
• Make all properties on Product protected
• Implement aggregate classes that expose the appropriate properties on Product depending on the kind of query
• Adjust the Elasticsearch logic to exclude source properties that aren't exposed by the aggregate

Add a factory to convert entities to an appropriate aggregate representation:

public AggregateFactory()
        {
            Mapper.CreateMap<Product, ProductDetails>();
            Mapper.CreateMap<Product, ProductSummary>();
        }

        public T AggregateFromProduct<T>(Product product)
            where T : Product
        {
            return Mapper.Map<T>(product);
        }

Could also use Mapper.DynamicMap<T>. Will also need to verify that the AutoMapper 3.3.0 initialisation using BindingFlags will work on Mono:

Mapper.Initialize(cfg =>
                {
                    cfg.BindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
                });

• Self-contained blocks of code with an input queue that handle their own failover
• Allow easy integration with Akka.NET
• Inject through IoC as lightweight pointers to the queue, so their appropriate Execute methods return immediately

Use a logger instead of just writing to Console so the logging debug info that's being added doesn't get wasted

Using the following Elasticsearch to support recursive variant matching:

POST products/_search
{
  "query": {
    "filtered": {
      "query": {
        "match_all": {}
      },
      "filter": {
        "term": {
          "_id": "fbe8b40e-0f3d-4dd9-bfc5-26389a1664a9"
        }
      }
    }
  },
  "script_fields": {
    "variants": {
      "script": "variant = _source.variants.find { v -> v.id == match_id } \n variant",
      "params": {
        "match_id": "my id"
      }
    }
  }
}

This needs to be adapted as follows:

• match_id should be an array of ids
• The script should recursively run through a for loop over match_id, and update the variant property to be the result of finding the variant with that id

At the moment things are messy, code is duplicated.

Refactor so common logic is standard, and look into trying to make the design scalable to n steps