public async Task Process(ShipmentMade message)
        {
            // Init the analyzer
            var analyzer = new ShipmentWide();

            ServiceDefinitions services = new ServiceDefinitions
            {
                ["couriers"] = new Service
                {
                    Endpoint = "/cqapi/couriers",
                    BaseUrl  = "aRandomSite.com"
                },
                ["shipments"] = new Service
                {
                    Endpoint = "/cqapi/shipments",
                    BaseUrl  = "aRandomSite.com"
                }
            };

            // Updating the services can be done anywhere, including startup.
            FluentOlapConfiguration.ServiceDefinitions = services;

            // Recieving the data
            var expandedData = await analyzer.PopulateAsync(new PopulationContext <ShipmentMade>(message));

            // Here the ingestion will take place.
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="serviceCollection"></param>
        /// <param name="services"></param>
        /// <param name="assemblies"></param>
        /// <returns></returns>
        public static IServiceCollection AddFluentOlap(
            this IServiceCollection serviceCollection,
            ServiceDefinitions serviceDefinitions,
            Action <TransformationsMasterList> transformationsMasterList,
            params Assembly[] assemblies)
        {
            IDictionary <string, TypeMap> maps        = new Dictionary <string, TypeMap>();
            IList <MessageProperties>     messageMaps = new List <MessageProperties>();

            serviceCollection.Scan(scan =>
            {
                var analyzerClasses = scan.FromAssemblies(assemblies)
                                      .AddClasses(classes => classes.AssignableTo(typeof(IAnalyticalNode))).AsImplementedInterfaces().WithTransientLifetime();
            });

            IEnumerable <ServiceDescriptor> services = serviceCollection.Where(
                a => a.ImplementationType != null &&
                a.ImplementationType.GetInterfaces().Any(b => b == typeof(IAnalyticalNode))
                );

            foreach (ServiceDescriptor service in services)
            {
                IAnalyticalNode instance = (IAnalyticalNode)Activator.CreateInstance(service.ImplementationType);

                if (instance.MessageMap == null)
                {
                    continue;
                }
                if (!maps.ContainsKey(instance.MessageMap.MessageName))
                {
                    maps.Add(instance.MessageMap.MessageName, instance.TypeMap);
                }

                if (messageMaps.All(m => m.MessageName != instance.MessageMap.MessageName))
                {
                    messageMaps.Add(instance.MessageMap);
                }
            }

            //serviceCollection.AddSingleton(serviceDefinitions);
            FluentOlapConfiguration.ServiceDefinitions = serviceDefinitions;
            serviceCollection.AddSingleton(new MasterTypeMaps(maps, messageMaps));
            return(serviceCollection);
        }