/// <summary>
        /// called from ViewComponent.
        /// </summary>
        public async Task <IViewComponentResult> InvokeAsync(List <int> paramsList)
        {
            if (!_context.ProductionOrderOperations.Any())
            {
                return(View(viewName: "ProductionTimeline", model: _ganttContext));
            }

            //.Definitions();
            var orders = new List <int>();

            _orderId         = paramsList[index : 0];
            _schedulingState = paramsList[index : 1];

            // If Order is not selected.
            if (_orderId == -1)
            {       // for all Orders
                orders = _context?.CustomerOrderParts.Select(selector: x => x.Id).ToList();
            }
            else
            {      // for the specified Order
                orders = _context?.CustomerOrderParts.Where(predicate: x => x.CustomerOrderId == _orderId).Select(selector: x => x.Id).ToList();
            }

            // Fill Select Fields
            var orderSelection = new SelectList(items: _context.CustomerOrders, dataValueField: "Id", dataTextField: "Name", selectedValue: _orderId);

            ViewData[index : "OrderId"] = orderSelection.AddFirstItem(firstItem : new SelectListItem {
                Value = "-1", Text = "All"
            });
            ViewData[index : "SchedulingState"] = SchedulingState(selectedItem : _schedulingState);

            // return schedule
            return(View(viewName: "ProductionTimeline", model: _ganttContext));
        }
        /// <summary>
        /// called from ViewComponent.
        /// </summary>
        public async Task <IViewComponentResult> InvokeAsync(List <int> paramsList)
        {
            if (!_context.ProductionOrderWorkSchedules.Any())
            {
                return(View("ProductionTimeline", _ganttContext));
            }

            //.Definitions();
            var orders = new List <int>();

            _orderId         = paramsList[0];
            _schedulingState = paramsList[1];

            // If Order is not selected.
            if (_orderId == -1)
            {       // for all Orders
                orders = _context?.OrderParts.Select(x => x.Id).ToList();
            }
            else
            {      // for the specified Order
                orders = _context?.OrderParts.Where(x => x.OrderId == _orderId).Select(x => x.Id).ToList();
            }

            await GetSchedulesForOrderListAsync(orders);

            // Fill Select Fields
            var orderSelection = new SelectList(_context.Orders, "Id", "Name", _orderId);

            ViewData["OrderId"] = orderSelection.AddFirstItem(new SelectListItem {
                Value = "-1", Text = "All"
            });
            ViewData["SchedulingState"] = SchedulingState(_schedulingState);

            // return schedule
            return(View("ProductionTimeline", _ganttContext));
        }
        /// <summary>
        /// called from ViewComponent.
        /// </summary>
        public async Task <IViewComponentResult> InvokeAsync(List <string> paramsList)
        {
            //.Definitions();
            var orders = new List <int>();

            _orderId                   = Convert.ToInt32(value: paramsList[index: 0]);
            _schedulingState           = Convert.ToInt32(value: paramsList[index: 1]);
            _schedulingPage            = Convert.ToInt32(value: paramsList[index: 2]);
            _simulationConfigurationId = Convert.ToInt32(value: paramsList[index: 4]);
            _simulationNumber          = Convert.ToInt32(value: paramsList[index: 5]);

            var folowLinks = false;

            switch (paramsList[index : 3])
            {
            case "Decentral" :
                _simulationType = SimulationType.Decentral;
                break;

            case "BackwardPlanning":
                _simulationType = SimulationType.BackwardPlanning;
                folowLinks      = true;
                break;

            case "ForwardPlanning":
                _simulationType = SimulationType.ForwardPlanning;
                folowLinks      = true;
                break;

            default:
                _simulationType = SimulationType.Central;
                break;
            }
            // refill ViewData
            // Fill Select Fields
            var orderSelection = new SelectList(items: _context.CustomerOrders, dataValueField: "Id", dataTextField: "Name", selectedValue: _orderId);

            ViewData[index : "OrderId"] = orderSelection.AddFirstItem(firstItem : new SelectListItem {
                Value = "-1", Text = "All"
            });
            ViewData[index : "SchedulingState"]         = SchedulingState(selectedItem : _schedulingState);
            ViewData[index : "SimulationPage"]          = _schedulingPage.ToString();
            ViewData[index : "SimulationType"]          = _simulationType.ToString();
            ViewData[index : "SimulationNumber"]        = _simulationNumber.ToString();
            ViewData[index : "SimulationConfiguration"] = _simulationConfigurationId.ToString();
            // - 1 caus we start with 0
            ViewData[index : "MaxPage"] = _maxPage;

            // if no data
            if (!_resultContext.SimulationOperations.Any())
            {
                return(View(viewName: "SimulationTimeline", model: _ganttContext));;
            }


            _timeSpan = _resultContext.SimulationConfigurations.Single(predicate: x => x.Id == _simulationConfigurationId).DynamicKpiTimeSpan;
            ///// Needs some changes to Work. i.e. Reference SimulationOrder , Create SimulationOrderPart and writing it back
            // If Order is not selected.
            if (_orderId == -1)
            {   // for all Orders
                await GetSchedulesForTimeSlotListAsync(pageStart : _timeSpan *_schedulingPage, pageEnd : _timeSpan *_schedulingPage + _timeSpan, folowLinks : folowLinks);
            }
            else
            {  // for the specified Order
                // temporary fix
                var tempType = (_simulationType == SimulationType.ForwardPlanning)
                    ? SimulationType.BackwardPlanning
                    : _simulationType;

                orders = _resultContext?.SimulationOrders.Where(predicate: x => x.OriginId == _orderId &&
                                                                x.SimulationType == tempType &&
                                                                x.SimulationNumber == _simulationNumber &&
                                                                x.SimulationConfigurationId == _simulationConfigurationId)
                         .Select(selector: x => x.OriginId).ToList();
                await GetSchedulesForOrderListAsync(ordersParts : orders);

                //orders = _context?.OrderParts.Where(x => x.OrderId == _orderId).Select(x => x.Id).ToList();
            }



            _ganttContext.Tasks = _ganttContext.Tasks.OrderBy(keySelector: x => x.type).ToList();
            // return schedule
            return(View(viewName: "SimulationTimeline", model: _ganttContext));
        }