Merge branch 'feature/VECTO-1731-declaration-mode-xev-primary-bus' of...

Merge branch 'feature/VECTO-1731-declaration-mode-xev-primary-bus' of https://citnet.tech.ec.europa.eu/CITnet/stash/scm/vecto/mq_vecto-dev into feature/VECTO-1731-declaration-mode-xev-primary-bus

VECTO3GUI2020/App.xaml

@@ -8,7 +8,8 @@
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
             <!-- Add new ResourceDictionaries here-->
-                <ResourceDictionary Source="Resources/ViewModelBindings.xaml"/>
+                <ResourceDictionary Source="/Resources/ViewModelBindings/ViewModelBindings.xaml"/>
+                <ResourceDictionary Source="/Resources/ViewModelBindings/VehicleViewModelBinding.xaml"/>
                 <ResourceDictionary Source="Resources/Converter.xaml"/>
                 <ResourceDictionary Source="Resources/MultistageParameterDataTemplates.xaml"/>
                 <ResourceDictionary Source="Resources\Styles\ButtonStyles.xaml"/>

VECTO3GUI2020/App.xaml.cs

@@ -3,6 +3,7 @@ using System.Windows;
 using Ninject;
 using TUGraz.VectoCore;
 using VECTO3GUI2020.Ninject;
+using VECTO3GUI2020.Ninject.Factories;
 using VECTO3GUI2020.Ninject.Vehicle;
 using VECTO3GUI2020.Properties;
 using Application = System.Windows.Application;
@@ -32,7 +33,6 @@ namespace VECTO3GUI2020
             container = new StandardKernel(
                 new VectoNinjectModule(),
                 new JobEditModule(),
-                new ComponentModule(),
 				new DocumentModule(),
 				new XMLWriterFactoryModule(),
                 new FactoryModule(),

VECTO3GUI2020/Helper/TemplateSelector/MultistageVehicleDataTemplateSelector.cs

@@ -29,7 +29,7 @@ namespace VECTO3GUI2020.Helper.TemplateSelector
 				Type type = null;
 
 				switch (vm) {
-					case InterimStageBusVehicleViewModel_v2_8 declvm:
+					case InterimStageBusVehicleViewModel declvm:
 						if (declvm.ExemptedVehicle) {
 							type = typeof(VehicleView_v2_8_exempted);
 						} else {

VECTO3GUI2020/Helper/XMLExtension.cs

@@ -6,12 +6,12 @@ using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Resources;
 using TUGraz.VectoCore.Utils;
 using VECTO3GUI2020.Util.XML;
-using VECTO3GUI2020.Util.XML.Interfaces;
+using VECTO3GUI2020.Util.XML.Components;
 
 
 namespace VECTO3GUI2020.Helper
 {
-	public static class XMLExtension
+    public static class XMLExtension
 	{
 		
 		public static XElement CreateSignatureElement(this IXMLComponentWriter componentWriter, XNamespace nameSpace, string uri, DigestData digestData, bool hash = false)

VECTO3GUI2020/Helper/XmlHelper.cs

@@ -42,7 +42,7 @@ namespace VECTO3GUI2020.Helper
 			if (xmlDocument == null)
 				return false;
 
-			var documentType = XMLHelper.GetDocumentType(xmlDocument.DocumentElement.LocalName);
+			var documentType = XMLHelper.GetDocumentTypeFromRootElement(xmlDocument.DocumentElement.LocalName);
 			if (documentType == null)
 			{
 				throw new VectoException("unknown xml file! {0}", xmlDocument.DocumentElement.LocalName);

VECTO3GUI2020/MainWindow.xaml

@@ -39,7 +39,7 @@
                             </MenuItem>
                             <Separator></Separator>
                             <MenuItem Header="{x:Static resx:GUILabels.CreateInterimCompletedInput}" Command="{Binding JobListVm.NewCompletedInputCommand}" />
-                            <MenuItem Header="{x:Static resx:GUILabels.CreateExemptedInterimCompletedInput}" Command="{Binding JobListVm.NewExemptedCompletedInputCommand}" />
+                            <!--<MenuItem Header="{x:Static resx:GUILabels.CreateExemptedInterimCompletedInput}" Command="{Binding JobListVm.NewExemptedCompletedInputCommand}" />-->
                         </MenuItem>
                         <MenuItem  Header="Load File" Command="{Binding JobListVm.AddJobAsyncCommand}"/>
                         <MenuItem Header="Settings" Command="{Binding OpenSettings}"/>
@@ -47,7 +47,7 @@
                     <MenuItem Header="Edit" VerticalAlignment="Stretch">
                         <MenuItem Header="Edit Job" ToolTip="Edit selected Job" Command="{Binding JobListVm.EditDocument}"/>
                         <MenuItem Header="Source File">
-                            <MenuItem Header="Show in Explorer" Command="{Binding JobListVm.ShowSourceFileCommand}"/>
+                            <MenuItem Header="Reveal in File Explorer" Command="{Binding JobListVm.ShowSourceFileCommand}"/>
                             <MenuItem Header="Open in Editor" Command="{Binding JobListVm.OpenSourceFileCommand}"/>
                         </MenuItem>
                         <!--<MenuItem Header="Simulate Job" ToolTip="Simulates the selected Job"/>-->

VECTO3GUI2020/Ninject/DocumentModule.cs

@@ -12,15 +12,17 @@ namespace VECTO3GUI2020.Ninject
         public override void Load()
         {
 
-            Bind<IDocumentViewModel>().To<DeclarationJobViewModel>().Named(XmlDocumentType.DeclarationJobData.ToString());
-			Bind<IDocumentViewModel>().To<MultiStageJobViewModel_v0_1>()
-				.Named(XmlDocumentType.MultistepOutputData.ToString());
+            //Bind<IDocumentViewModel>().To<DeclarationJobViewModel>().Named(XmlDocumentType.DeclarationJobData.ToString());
 
-			Bind<IDocumentViewModel>().To<CreateVifViewModel>()
-				.Named(typeof(JSONInputDataV10_PrimaryAndStageInputBus).ToString());
 
-			Bind<IDocumentViewModel>().To<CompletedBusV7ViewModel>()
-				.Named(typeof(JSONInputDataCompletedBusFactorMethodV7).ToString());
+			//Bind<IDocumentViewModel>().To<MultiStageJobViewModel_v0_1>()
+			//	.Named(XmlDocumentType.MultistepOutputData.ToString());
+
+			//Bind<IDocumentViewModel>().To<CreateVifViewModel>()
+			//	.Named(typeof(JSONInputDataV10_PrimaryAndStageInputBus).ToString());
+
+			//Bind<IDocumentViewModel>().To<CompletedBusV7ViewModel>()
+			//	.Named(typeof(JSONInputDataCompletedBusFactorMethodV7).ToString());
 
 			//Bind<IDocumentViewModel>().To<MultistageJobViewModel>().Named(XmlDocumentType.MultistageOutputData.ToString());
 			//Bind<IDocumentViewModel>().To<DeclarationTrailerJobDocumentViewModel>().Named(XmlDocumentType.DeclarationTrailerJobData.ToString());

VECTO3GUI2020/Ninject/Factories/ComponentViewModelFactoryModule.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.AccessControl;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using Ninject.Extensions.Factory;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+using VECTO3GUI2020.ViewModel.Implementation.JobEdit.Vehicle.Components;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle.Components;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+	
+	public interface IComponentViewModelFactoryInternal
+	{
+		IComponentViewModel CreateComponentViewModel(DataSource source, object inputData);
+		ICommonComponentViewModel CreateCommonComponentViewModel(object inputData);
+
+
+	}
+
+
+    public class ComponentViewModelFactoryModule : AbstractNinjectModule
+	{
+		private IComponentViewModelFactoryInternal factory;
+		private const string scopeName = nameof(IComponentViewModelFactory);
+		private const string common = "common";
+
+		#region Overrides of NinjectModule
+
+		public override void Load()
+		{
+			Bind<IComponentViewModelFactory>().To<ComponentViewModelFactory>();
+            Bind<IComponentViewModelFactoryInternal>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(new[] {
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					methods = new []{typeof(IComponentViewModelFactoryInternal).GetMethod(nameof(IComponentViewModelFactoryInternal.CreateComponentViewModel))},
+					combineToNameDelegate = CombineToNameDelegate,
+					skipArguments = 1,
+					takeArguments = 1,
+				},
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					methods = new []{typeof(IComponentViewModelFactoryInternal).GetMethod(nameof(IComponentViewModelFactoryInternal.CreateCommonComponentViewModel))},
+					combineToNameDelegate = arguments => common,
+					skipArguments = 0,
+					takeArguments = 0,
+				}
+			})).Named(scopeName);
+
+			Bind<ICommonComponentViewModel>().To<CommonComponentViewModel>().WhenAnyAncestorNamed(scopeName).Named(common);
+			AddInternalComponentBinding<AirDragViewModel_v1_0>(XMLDeclarationAirdragDataProviderV10.NAMESPACE_URI, XMLDeclarationAirdragDataProviderV10.XSD_TYPE);
+			AddInternalComponentBinding<AirDragViewModel_v2_0>(XMLDeclarationAirdragDataProviderV20.NAMESPACE_URI, XMLDeclarationAirdragDataProviderV20.XSD_TYPE);
+			AddInternalComponentBinding<AirDragViewModel_v2_4>(XMLDeclarationAirdragDataProviderV24.NAMESPACE_URI, XMLDeclarationAirdragDataProviderV24.XSD_TYPE);
+
+
+
+
+		}
+
+		private void AddInternalComponentBinding<TConcrete>(XNamespace ns, string type) where TConcrete : IComponentViewModel
+		{
+			Bind<IComponentViewModel>().To<TConcrete>().WhenAnyAncestorNamed(scopeName).Named(CombineToName(ns, type));
+		}
+
+		private string CombineToNameDelegate(object[] arguments)
+		{
+			if (arguments.Length >= 1 && arguments[0] is DataSource dataSource) {
+				XNamespace ns = dataSource.TypeVersion;
+				var type = dataSource.Type;
+				return CombineToName(ns, xsdType: type);
+			}
+
+			throw new ArgumentException($"First argument must be of type {typeof(DataSource)}");
+
+		}
+
+		private string CombineToName(XNamespace ns, string xsdType)
+		{
+			return XMLHelper.CombineNamespace(ns, xsdType);
+		}
+		#endregion
+	}
+}

VECTO3GUI2020/Ninject/Factories/DocumentViewModelFactoryModule.cs

+using System;
+using Ninject.Extensions.Factory;
+using Ninject.Modules;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.InputData.FileIO.XML;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider.v24;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+using VECTO3GUI2020.Helper;
+using VECTO3GUI2020.ViewModel.Implementation.Common;
+using VECTO3GUI2020.ViewModel.Implementation.Document;
+using VECTO3GUI2020.ViewModel.Interfaces.Document;
+using VECTO3GUI2020.ViewModel.MultiStage.Implementation;
+using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+    public class DocumentViewModelFactoryModule : NinjectModule
+    {
+        #region Overrides of NinjectModule
+
+        public const string DocumentViewModelFactoryScope = nameof(IDocumentViewModelFactory);
+        public const string MultistepInputScope = nameof(IMultiStepInputViewModelFactory);
+        public const string DeclarationViewModelScope = nameof(IDeclarationInputViewModelFactory);
+
+        public const string NewDocumentViewModelScope = nameof(INewDocumentViewModelFactory);
+
+
+        public const string PrimaryAndStageInputScope = nameof(IPrimaryAndStageInputViewModelFactory);
+
+        public override void Load()
+        {
+            Bind<IDocumentViewModelFactory>().To<DocumentViewModelFactory>().InSingletonScope().Named(DocumentViewModelFactoryScope);
+
+            #region MultistepViewModel
+
+            Bind<IMultiStepInputViewModelFactory>().ToFactory().InSingletonScope().Named(MultistepInputScope);
+            Bind<IDocumentViewModel>().To<MultiStageJobViewModel_v0_1>().WhenParentNamed(MultistepInputScope);
+            #endregion
+
+            #region DeclarationInputData
+
+            Bind<IDeclarationInputViewModelFactory>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(true,
+                new[] {
+                    new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+                        methods = new []{typeof(IDeclarationInputViewModelFactory).GetMethod(nameof(IDeclarationInputViewModelFactory.CreateDeclarationViewModel))},
+                        takeArguments = 1,
+                        combineToNameDelegate = (arguments) => {
+                            if (arguments == null || arguments.Length < 1) {
+                                throw new ArgumentException("Invalid number of arguments");
+                            }
+
+                            if (arguments[0] is IDeclarationInputDataProvider inputData) {
+                                var name =  $"{inputData.JobInputData.Vehicle.DataSource.SourceVersion}:{inputData.JobInputData.Vehicle.DataSource.Type}";
+                                return name;
+                            }
+
+                            throw new ArgumentException($"Invalid argument of type {arguments[0].GetType()}");
+                        }
+                    },
+                }
+            )
+            ).Named(DeclarationViewModelScope);
+            Bind<IDocumentViewModel>().To<SimulationOnlyDeclarationJob>().WhenParentNamed(DeclarationViewModelScope);
+
+            var StageInputXMLVersions = new[] {
+                new { XMLDeclarationConventionalCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationConventionalCompletedBusDataProviderV24.XSD_TYPE},
+                new { AbstractXMLDeclarationCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationHevCompletedBusDataProviderV24.XSD_TYPE},
+                new { AbstractXMLDeclarationCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationPEVCompletedBusDataProviderV24.XSD_TYPE},
+                new { XMLDeclarationExemptedCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationExemptedCompletedBusDataProviderV24.XSD_TYPE},
+                new { AbstractXMLDeclarationCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationIepcCompletedBusDataProviderV24.XSD_TYPE},
+                };
+            foreach (var version in StageInputXMLVersions)
+            {
+                var name = $"{version.NAMESPACE_URI.GetVersionFromNamespaceUri()}:{version.XSD_TYPE}";
+
+                Bind<IDocumentViewModel>().To<StageInputViewModel>().WhenParentNamed(DeclarationViewModelScope)
+                    .Named(name);
+            }
+            #endregion
+
+
+            #region NewViewModels
+
+            Bind<INewDocumentViewModelFactory>().ToFactory().Named(NewDocumentViewModelScope);
+            Bind<IDocumentViewModel>().ToConstructor(
+                constructorArgs => new StageInputViewModel(
+                    constructorArgs.Inject<bool>(),
+                    constructorArgs.Inject<IMultiStageViewModelFactory>(),
+                    constructorArgs.Inject<IAdditionalJobInfoViewModel>()))
+                .WhenParentNamed(NewDocumentViewModelScope)
+                .NamedLikeFactoryMethod((INewDocumentViewModelFactory f) => f.GetCreateNewStepInputViewModel(false)); ;
+
+            Bind<IDocumentViewModel>().ToConstructor(
+                constructorArgs => new CreateVifViewModel(
+                    constructorArgs.Inject<bool>(),
+                    constructorArgs.Inject<IDialogHelper>(),
+                    constructorArgs.Inject<IXMLInputDataReader>(),
+                    constructorArgs.Inject<IAdditionalJobInfoViewModel>()))
+                .WhenParentNamed(NewDocumentViewModelScope)
+                .NamedLikeFactoryMethod((INewDocumentViewModelFactory f) => f.GetCreateNewVifViewModel(false));
+
+            #endregion
+
+            Bind<IPrimaryAndStageInputViewModelFactory>().ToFactory().Named(PrimaryAndStageInputScope);
+            Bind<IDocumentViewModel>().To<CreateVifViewModel>().WhenParentNamed(PrimaryAndStageInputScope);
+        }
+        #endregion
+    }
+}

VECTO3GUI2020/Ninject/Factories/FactoryModule.cs

+using Ninject.Extensions.Factory;
+using TUGraz.VectoCore;
+using VECTO3GUI2020.Ninject.Util;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit;
+using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+    public class FactoryModule : AbstractNinjectModule
+    {
+        public override void Load()
+        {
+            LoadModule<DocumentViewModelFactoryModule>();
+            LoadModule<ComponentViewModelFactoryModule>();
+            LoadModule<VehicleViewModelFactoryModule>();
+            LoadModule<XMLWriterFactoryModule>();
+			LoadModule<MultistepComponentViewModelFactory>();
+
+            //Bind<IXMLWriterFactory>().ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider(fallback: true));
+            //Bind<IMultiStageViewModelFactory>().ToFactory(() => new UseFirstArgumentAsNameInstanceProvider(skipFirstArgument: true, fallback: true));
+
+            Bind<IJobEditViewModelFactory>().ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider());
+
+
+
+
+
+
+            Bind<IMultiStageViewModelFactory>().To<MultiStageViewModelFactory>().
+                InSingletonScope();
+            Bind<IMultiStageViewModelFactoryDefaultInstanceProvider>().
+                ToFactory();
+            //Bind<IMultiStageViewModelFactoryTypeAsNameInstanceProvider>().
+            //	ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider());
+            Bind<IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider>().ToFactory(() =>
+                new UseFirstArgumentAsNameInstanceProvider(skipFirstArgument: false));
+
+        }
+    }
+}

VECTO3GUI2020/Ninject/Factories/MultiStageViewModelFactory.cs

+using Ninject;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.InputData.FileIO.XML;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider.v24;
+using TUGraz.VectoCore.Models.Simulation;
+using TUGraz.VectoCore.Utils;
+using VECTO3GUI2020.ViewModel.Implementation;
+using VECTO3GUI2020.ViewModel.Implementation.Common;
+using VECTO3GUI2020.ViewModel.Implementation.Document;
+using VECTO3GUI2020.ViewModel.Interfaces;
+using VECTO3GUI2020.ViewModel.Interfaces.Common;
+using VECTO3GUI2020.ViewModel.Interfaces.Document;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle.Components;
+using VECTO3GUI2020.ViewModel.MultiStage.Implementation;
+using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+    public class MultiStageViewModelFactory : IMultiStageViewModelFactory
+    {
+        private IMultiStageViewModelFactoryDefaultInstanceProvider _multiStageVmFactoryDefaultInstanceProvider;
+
+        private IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider
+            _multistageViewModelFactoryFirstParameterAsNameInstanceProvider;
+
+        private readonly IDocumentViewModelFactory _documentViewModelFactory;
+		private readonly IVehicleViewModelFactory _vehicleViewModelFactory;
+        private readonly IMultistepComponentViewModelFactory _multistepComponentViewModelFactory;
+
+        public MultiStageViewModelFactory(
+            IMultiStageViewModelFactoryDefaultInstanceProvider multiStageVmFactoryDefaultInstanceProvider,
+            IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider multistageViewModelFactoryFirstParameterAsNameInstanceProvider,
+            IDocumentViewModelFactory documentViewModelFactory,
+            IVehicleViewModelFactory vehicleViewModelFactory, IMultistepComponentViewModelFactory multistepComponentViewModelFactory)
+        {
+            _multiStageVmFactoryDefaultInstanceProvider = multiStageVmFactoryDefaultInstanceProvider;
+            _multistageViewModelFactoryFirstParameterAsNameInstanceProvider = multistageViewModelFactoryFirstParameterAsNameInstanceProvider;
+
+			_multistepComponentViewModelFactory = multistepComponentViewModelFactory;
+            _documentViewModelFactory = documentViewModelFactory;
+            _vehicleViewModelFactory = vehicleViewModelFactory;
+        }
+
+        #region Implementation of IMultiStageViewModelFactoryDefaultInstanceProvider
+
+        public IViewModelBase GetNewMultistageJobViewModel()
+        {
+            return _multiStageVmFactoryDefaultInstanceProvider.GetNewMultistageJobViewModel();
+        }
+
+        public IMultiStageJobViewModel GetMultiStageJobViewModel(IMultistepBusInputDataProvider inputData)
+        {
+            return _documentViewModelFactory.CreateDocumentViewModel(inputData) as IMultiStageJobViewModel;
+        }
+
+        public IMultistageVehicleViewModel GetInterimStageVehicleViewModel(CompletedBusArchitecture arch)
+        {
+
+			if (_vehicleViewModelFactory.CreateNewVehicleViewModel(arch) is IMultistageVehicleViewModel veh) {
+				return veh;
+			};
+			throw new VectoException($"Could not create viewmodel for {arch} completed bus!");
+		}
+
+        public IVehicleViewModel GetInterimStageVehicleViewModel(IVehicleDeclarationInputData consolidatedVehicleData, bool exempted)
+		{
+			return _vehicleViewModelFactory.CreateVehicleViewModel(consolidatedVehicleData, null);
+		}
+
+		public IMultistageVehicleViewModel GetInterimStageVehicleViewModel(IVehicleDeclarationInputData inputData)
+		{
+			return _vehicleViewModelFactory.CreateVehicleViewModel(null, vehicleInput: inputData) as IMultistageVehicleViewModel;
+		}
+
+        public IManufacturingStageViewModel GetManufacturingStageViewModel(
+            IManufacturingStageInputData consolidatedManufacturingStageInputData, bool exempted)
+        {
+            return _multiStageVmFactoryDefaultInstanceProvider.GetManufacturingStageViewModel(consolidatedManufacturingStageInputData, exempted);
+        }
+
+        public IMultistageAirdragViewModel GetMultistageAirdragViewModel()
+        {
+            return _multiStageVmFactoryDefaultInstanceProvider.GetMultistageAirdragViewModel();
+        }
+
+        public IMultistageAirdragViewModel GetMultistageAirdragViewModel(IAirdragDeclarationInputData consolidatedAirdragInputData)
+        {
+            return _multiStageVmFactoryDefaultInstanceProvider.GetMultistageAirdragViewModel(consolidatedAirdragInputData);
+        }
+
+        public IMultistageAuxiliariesViewModel GetAuxiliariesViewModel(
+			CompletedBusArchitecture arch)
+        {
+            return _multistepComponentViewModelFactory.CreateNewMultistepBusAuxViewModel(arch);
+        }
+
+        public IMultistageAuxiliariesViewModel
+			GetAuxiliariesViewModel(CompletedBusArchitecture arch,
+				IBusAuxiliariesDeclarationData consolidatedAuxiliariesInputData)
+        {
+            return _multistepComponentViewModelFactory.CreateNewMultistepBusAuxViewModel(arch);
+        }
+
+        #endregion
+
+
+
+
+
+        #region Implementation of IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider
+
+        public IVehicleViewModel CreateStageInputVehicleViewModel(string inputProviderType)
+        {
+            return _multistageViewModelFactoryFirstParameterAsNameInstanceProvider.CreateStageInputVehicleViewModel(inputProviderType);
+        }
+
+        #endregion
+
+        #region Implementation of IDocumentViewModelFactory
+
+        public IDocumentViewModel CreateDocumentViewModel(IInputDataProvider declarationInput)
+        {
+            return _documentViewModelFactory.CreateDocumentViewModel(declarationInput);
+        }
+
+        public IDocumentViewModel GetCreateNewStepInputViewModel(bool exemptedVehicle)
+        {
+            return _documentViewModelFactory.GetCreateNewStepInputViewModel(exemptedVehicle);
+        }
+
+        public IDocumentViewModel GetCreateNewVifViewModel(bool completed)
+        {
+            return _documentViewModelFactory.GetCreateNewVifViewModel(completed);
+        }
+
+        #endregion
+
+    }
+}
\ No newline at end of file

VECTO3GUI2020/Ninject/Factories/MultistageViewModelModule.cs

+using System;
+using System.Diagnostics;
+using System.Xml.Linq;
+using Ninject.Extensions.Factory;
+using Ninject.Modules;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+using VECTO3GUI2020.Model.Multistage;
+using VECTO3GUI2020.ViewModel.Implementation.Common;
+using VECTO3GUI2020.ViewModel.Interfaces.Common;
+using VECTO3GUI2020.ViewModel.Interfaces.Document;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle;
+using VECTO3GUI2020.ViewModel.MultiStage.Implementation;
+using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+	public interface IMultistepComponentViewModelFactory
+	{
+		IMultistageAuxiliariesViewModel CreateMultistepBusAuxViewModel(CompletedBusArchitecture arch, IBusAuxiliariesDeclarationData consolidatedInputData);
+		IMultistageAuxiliariesViewModel CreateNewMultistepBusAuxViewModel(CompletedBusArchitecture arch);
+	}
+
+
+	public class MultistepComponentViewModelFactory : AbstractNinjectModule
+	{
+		private string scopeName = "MultistepComponent";
+		#region Overrides of NinjectModule
+
+		public override void Load()
+		{
+			Bind<IMultistepComponentViewModelFactory>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(new[] {
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					methods = new[] {
+						typeof(IMultistepComponentViewModelFactory).GetMethod(nameof(IMultistepComponentViewModelFactory.CreateNewMultistepBusAuxViewModel)),
+						typeof(IMultistepComponentViewModelFactory).GetMethod(nameof(IMultistepComponentViewModelFactory.CreateMultistepBusAuxViewModel))
+					},
+					combineToNameDelegate = (args) => {
+						if (args.Length >= 1 && args[0] is CompletedBusArchitecture arch) {
+							return arch.ToString();
+						}
+						throw new ArgumentException($"arg[0] must be {nameof(CompletedBusArchitecture)}");
+					},
+					skipArguments = 1,
+					takeArguments = 1
+				}
+			})).Named(scopeName);
+			AddBinding<IMultistageAuxiliariesViewModel, MultistageAuxiliariesViewModel_Conventional>(CompletedBusArchitecture.Conventional);
+			AddBinding<IMultistageAuxiliariesViewModel, MultistageAuxiliariesViewModel_xEV>(CompletedBusArchitecture.HEV);
+			AddBinding<IMultistageAuxiliariesViewModel, MultistageAuxiliariesViewModel_xEV>(CompletedBusArchitecture.PEV);
+			AddBinding<IMultistageAuxiliariesViewModel, MultistageAuxiliariesViewModel_xEV>(CompletedBusArchitecture.IEPC);
+		}
+
+		[DebuggerStepThrough]
+		public string GetName(CompletedBusArchitecture arch)
+		{
+			return arch.ToString();
+		}
+		#endregion
+
+
+		public void AddBinding<TInterface, TConcrete>(CompletedBusArchitecture arch)
+			where TConcrete : class, TInterface
+		{
+			Bind<TInterface>().To<TConcrete>().WhenParentNamed(scopeName).Named(GetName(arch));
+		}
+
+	}
+
+}

VECTO3GUI2020/Ninject/Factories/VehicleViewModelFactory.cs

+using System;
+using System.Reflection;
+using System.Xml.Linq;
+using Ninject.Extensions.Factory;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider.v24;
+using TUGraz.VectoCore.Models.SimulationComponent;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+using VECTO3GUI2020.Annotations;
+using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle;
+using VECTO3GUI2020.ViewModel.MultiStage.Implementation;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+
+	public interface IVehicleViewModelFactory
+	{
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="consolidatedInputData">null if an exisiting step input should be used</param>
+		/// <param name="stepInputData">null if a new step inputviewmodel should be created</param>
+		/// <param name="exempted"></param>
+		/// <returns></returns>
+		IVehicleViewModel CreateVehicleViewModel(IVehicleDeclarationInputData consolidatedVehicleData, IVehicleDeclarationInputData vehicleInput);
+
+		IVehicleViewModel CreateNewVehicleViewModel(CompletedBusArchitecture arch);
+	}
+
+	public class VehicleViewModelFactoryModule : AbstractNinjectModule
+	{
+		#region Overrides of NinjectModule
+
+		private const string scopeName = nameof(IVehicleViewModelFactory);
+		public override void Load()
+		{
+			Bind<IVehicleViewModelFactory>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(new[] {
+				///From consolidated data
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					combineToNameDelegate = (args) => {
+						if (args.Length >= 2) {
+							//Step inputviewmodel with consolidate vehicle data from previous steps
+							if (args[0] is IVehicleDeclarationInputData consolidatedVehicle) {
+								return ArchName(consolidatedVehicle.VehicleType, consolidatedVehicle.ExemptedVehicle).ToString();
+							}
+
+							//Standalone step input
+							if (args[1] is IVehicleDeclarationInputData vehicle) {
+								return CombineToName(vehicle.DataSource.TypeVersion, vehicle.DataSource.Type);
+							}
+						}
+						throw new ArgumentException($"arg[0] must be {nameof(IVehicleDeclarationInputData)}");
+					},
+					methods = new []{typeof(IVehicleViewModelFactory).GetMethod(nameof(IVehicleViewModelFactory.CreateVehicleViewModel))},
+					takeArguments = 2,
+					skipArguments = 0,
+				},
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					methods = new[]{typeof(IVehicleViewModelFactory).GetMethod(nameof(IVehicleViewModelFactory.CreateNewVehicleViewModel))},
+					combineToNameDelegate = (args) => {
+						if (args.Length >= 1 && args[0] is CompletedBusArchitecture arch) {
+							return arch.ToString();
+						}
+						throw new ArgumentException($"arg[0] must be {nameof(CompletedBusArchitecture)}");
+                    },
+					skipArguments = 1,
+					takeArguments = 1
+				}
+			})).Named(scopeName);
+
+            ///Empty vehicle view models //Create depending on jobtype
+			AddVehicleViewModelBinding<InterimStageConventionalBusVehicleViewModel>(VectoSimulationJobType.ConventionalVehicle);
+			//One for hev is enough map to same name
+			AddVehicleViewModelBinding<InterimStageHevBusVehicleViewModel>(         VectoSimulationJobType.ParallelHybridVehicle);
+
+			AddVehicleViewModelBinding<InterimStagePevBusVehicleViewModel>(         VectoSimulationJobType.BatteryElectricVehicle);
+
+			AddVehicleViewModelBinding<InterimStageIEPCBusVehicleViewModel>(VectoSimulationJobType.IEPC_E);
+
+			AddVehicleViewModelBinding<InterimStageExemptedBusVehicleViewModel>(VectoSimulationJobType.EngineOnlySimulation, true);
+
+			
+
+            ///Vehicle Viewmodels for existing files
+            AddVehicleViewModelBinding<InterimStageConventionalBusVehicleViewModel>(XMLDeclarationConventionalCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationConventionalCompletedBusDataProviderV24.XSD_TYPE);
+			AddVehicleViewModelBinding<InterimStageHevBusVehicleViewModel>(XMLDeclarationHevCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationHevCompletedBusDataProviderV24.XSD_TYPE);
+			
+			AddVehicleViewModelBinding<InterimStagePevBusVehicleViewModel>(XMLDeclarationPEVCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationPEVCompletedBusDataProviderV24.XSD_TYPE);
+			AddVehicleViewModelBinding<InterimStageIEPCBusVehicleViewModel>(XMLDeclarationIepcCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationIepcCompletedBusDataProviderV24.XSD_TYPE);
+
+            AddVehicleViewModelBinding<InterimStageExemptedBusVehicleViewModel>(XMLDeclarationExemptedCompletedBusDataProviderV24.NAMESPACE_URI, XMLDeclarationExemptedCompletedBusDataProviderV24.XSD_TYPE); 
+
+        }
+
+        #endregion
+		private void AddVehicleViewModelBinding<TConcrete>(XNamespace ns, string type) where TConcrete : IVehicleViewModel
+		{
+			Bind<IVehicleViewModel>().To<TConcrete>().WhenAnyAncestorNamed(scopeName).Named(CombineToName(ns, type));
+		}
+
+		private void AddVehicleViewModelBinding<TConcrete>(VectoSimulationJobType jobType, bool exempted = false) where TConcrete : IVehicleViewModel
+		{
+			Bind<IVehicleViewModel>().To<TConcrete>().WhenAnyAncestorNamed(scopeName).Named(ArchName(jobType, exempted).ToString());
+		}
+
+
+		public static CompletedBusArchitecture ArchName(VectoSimulationJobType jobType, bool exempted = false)
+		{
+			if (exempted) {
+				return CompletedBusArchitecture.Exempted;
+			}
+			switch(jobType){
+				case VectoSimulationJobType.ConventionalVehicle:
+					return CompletedBusArchitecture.Conventional;
+				case VectoSimulationJobType.ParallelHybridVehicle:
+				case VectoSimulationJobType.SerialHybridVehicle:
+				case VectoSimulationJobType.IHPC:
+                    return CompletedBusArchitecture.HEV;
+				case VectoSimulationJobType.BatteryElectricVehicle:
+					return CompletedBusArchitecture.PEV;
+				case VectoSimulationJobType.IEPC_E:
+				case VectoSimulationJobType.IEPC_S:
+					return CompletedBusArchitecture.IEPC;
+				default:
+					throw new ArgumentOutOfRangeException(nameof(jobType), jobType, null);
+			}
+		}
+        public static string CombineToName(XNamespace ns, string type)
+		{
+			return XMLHelper.CombineNamespace(ns, type);
+		}
+	}
+
+
+
+
+
+}
+
+
+

VECTO3GUI2020/Ninject/Factories/XMLWriterFactoryModule.cs

+using System;
+using System.Diagnostics;
+using System.Xml.Linq;
+using Ninject.Extensions.Factory;
+using Ninject.Modules;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+using VECTO3GUI2020.Ninject.Util;
+using VECTO3GUI2020.Resources.XML;
+using VECTO3GUI2020.Util.XML;
+using VECTO3GUI2020.Util.XML.Components;
+
+using VECTO3GUI2020.Util.XML.Vehicle;
+
+namespace VECTO3GUI2020.Ninject.Factories
+{
+    public class XMLWriterFactoryModule : NinjectModule
+	{
+		private const string vehicleScope = nameof(IXMLWriterFactoryInternal);
+		public override void Load()
+		{
+			Bind<IXMLWriterFactory>().To<XMLWriterFactory>().InSingletonScope();
+
+
+			Bind<IXMLWriterFactoryInternal>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(false, new [] {
+				new CombineArgumentsToNameInstanceProvider.MethodSettings() {
+					combineToNameDelegate = ((args) => {
+						if (args[0] is DataSource dataSource) {
+							return GetName(dataSource.TypeVersion, dataSource.Type);
+						}
+						throw new ArgumentException();
+					}),
+					methods = new [] {
+						typeof(IXMLWriterFactoryInternal).GetMethod(nameof(IXMLWriterFactoryInternal.CreateWriter)),
+                        typeof(IXMLWriterFactoryInternal).GetMethod(nameof(IXMLWriterFactoryInternal.CreateComponentsWriter)),
+						typeof(IXMLWriterFactoryInternal).GetMethod(nameof(IXMLWriterFactoryInternal.CreateComponentWriter))
+                    },
+					skipArguments = 1,
+					takeArguments = 1,
+				}
+			})).InSingletonScope().Named(vehicleScope);
+
+			Array.ForEach(XMLCompletedBusVehicleWriterConventional.SUPPORTEDVERSIONS, sv => AddVehicleWriterBinding<XMLCompletedBusVehicleWriterConventional>(sv.version, sv.type));
+
+			Array.ForEach(XMLCompletedBusVehicleWriterExempted.SUPPORTEDVERSIONS, sv => AddVehicleWriterBinding<XMLCompletedBusVehicleWriterExempted>(sv.version, sv.type));
+            #region Vehicle
+            AddVehicleWriterBinding<XMLCompletedBusVehicleWriterHEV>(XMLCompletedBusVehicleWriterHEV.VERSION);
+			AddVehicleWriterBinding<XMLCompletedBusVehicleWriterPEV>(XMLCompletedBusVehicleWriterPEV.VERSION);
+			AddVehicleWriterBinding<XMLCompletedBusVehicleWriterIEPC>(XMLCompletedBusVehicleWriterIEPC.VERSION);
+
+            #endregion Vehicle
+
+            #region Components
+            AddComponentsWriterBinding<XMLCompletedBusComponentWriter_Conventional>(XMLCompletedBusComponentWriter_Conventional.VERSION);
+            AddComponentsWriterBinding<XMLCompletedBusComponentsWriter_xEV>(XMLCompletedBusComponentsWriter_xEV.VERSION);
+
+
+            #endregion
+
+            #region Airdrag
+            AddComponentWriterBinding<XMLAirDragWriter_v2_0>(XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V20, XMLTypes.AirDragDataDeclarationType);
+			AddComponentWriterBinding<XMLAirDragWriter_v1_0>(XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V10, XMLTypes.AirDragDataDeclarationType);
+			AddComponentWriterBinding<XMLAirDragWriter_v2_4>(XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V24, XMLTypes.AirDragModifiedUseStandardValueType);
+
+            #endregion
+
+            #region BusAux
+            AddBusAuxWriterBinding<XMLCompletedBusAuxiliariesWriterConventional>(XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V24, XMLTypes.AUX_Conventional_CompletedBusType);
+            AddBusAuxWriterBinding<XMLCompletedBusAuxiliariesWriter_xEV>(XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V24, XMLTypes.AUX_xEV_CompletedBusType);
+			#endregion
+
+
+            #region
+
+
+
+
+
+            //Array.ForEach(
+            //    XMLComponentsWriter_v1_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentsWriter>().To<XMLComponentsWriter_v1_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLComponentsWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentsWriter>().To<XMLComponentsWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLEngineWriter_v1_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLEngineWriter_v1_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLEngineWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLEngineWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLGearboxWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLGearboxWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLRetarderWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLRetarderWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLAxleGearWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLAxleGearWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLAxleWheelsWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLAxleWheelsWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLAxleWheelWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLAxleWheelWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLTyreWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLTyreWriter_v2_0>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLTyreWriter_v2_3.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLTyreWriter_v2_3>().Named(sv));
+
+            //Array.ForEach(
+            //    XMLAuxiliariesWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLAuxiliariesWriter_v2_0>().Named(sv));
+            //Array.ForEach(
+            //    XMLAirDragWriter_v2_0.SUPPORTED_VERSIONS,
+            //    sv => Bind<IXMLComponentWriter>().To<XMLAirDragWriter_v2_0>().Named(sv));
+
+            //Bind<IXMLBusAuxiliariesWriter>().To<XMLCompletedBusAuxiliariesWriterConventional>();
+
+            #endregion
+
+        }
+
+        public string GetName(XNamespace version, string xsdType)
+		{
+			return XMLHelper.CombineNamespace(version, xsdType);
+		}
+
+		private void AddVehicleWriterBinding<TConcrete>((XNamespace ns, string xsdType) version) where TConcrete : class, IXMLVehicleWriter
+		{
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version.ns, version.xsdType)}'");
+			Bind<IXMLVehicleWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version.ns, version.xsdType));
+		}
+        private void AddVehicleWriterBinding<TConcrete>(XNamespace version, string xsdType) where TConcrete : class, IXMLVehicleWriter
+		{
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version, xsdType)}'");
+			Bind<IXMLVehicleWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version, xsdType));
+		}
+		private void AddComponentsWriterBinding<TConcrete>((XNamespace version, string xsdType) version)
+			where TConcrete : class, IXMLComponentsWriter
+		{
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version.version, version.xsdType)}'");
+			Bind<IXMLComponentsWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version.version, version.xsdType));
+		}
+
+        private void AddComponentsWriterBinding<TConcrete>(XNamespace version, string xsdType)
+			where TConcrete : class, IXMLComponentsWriter
+		{
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version, xsdType)}'");
+			Bind<IXMLComponentsWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version, xsdType));
+        }
+
+		private void AddComponentWriterBinding<TConcrete>(XNamespace version, string xsdType) where TConcrete : class, IXMLComponentWriter
+        {
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version, xsdType)}'");
+			Bind<IXMLComponentWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version, xsdType));
+		}
+
+		private void AddBusAuxWriterBinding<TConcrete>(XNamespace version, string xsdType)
+			where TConcrete : class, IXMLBusAuxiliariesWriter
+		{
+			Debug.WriteLine($"Create Binding for {typeof(TConcrete)} named '{GetName(version, xsdType)}'");
+			Bind<IXMLBusAuxiliariesWriter>().To<TConcrete>().WhenParentNamed(vehicleScope).Named(GetName(version, xsdType));
+        }
+	}
+}

VECTO3GUI2020/Ninject/FactoryModule.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Ninject.Extensions.Factory;
-using Ninject.Modules;
-using VECTO3GUI2020.Ninject.Util;
-using VECTO3GUI2020.Util.XML.Interfaces;
-using VECTO3GUI2020.ViewModel.Interfaces.Document;
-using VECTO3GUI2020.ViewModel.Interfaces.JobEdit;
-using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle.Components;
-using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
-
-namespace VECTO3GUI2020.Ninject
-{
-    public class FactoryModule : NinjectModule
-    {
-		public override void Load()
-		{
-			Bind<IXMLWriterFactory>().ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider(fallback:true));
-			//Bind<IMultiStageViewModelFactory>().ToFactory(() => new UseFirstArgumentAsNameInstanceProvider(skipFirstArgument: true, fallback: true));
-			
-			Bind<IJobEditViewModelFactory>().ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider());
-			Bind<IDocumentViewModelFactory>().ToFactory(() => new UseFirstArgumentAsNameInstanceProvider(false));
-			Bind<IComponentViewModelFactory>().ToFactory(
-				() => new UseFirstArgumentTypeAsNameInstanceProvider(true));
-
-
-			Bind<IMultiStageViewModelFactory>().To<MultiStageViewModelFactory>().
-				InSingletonScope();
-			Bind<IMultiStageViewModelFactoryDefaultInstanceProvider>().
-				ToFactory();
-			Bind<IMultiStageViewModelFactoryTypeAsNameInstanceProvider>().
-				ToFactory(() => new UseFirstArgumentTypeAsNameInstanceProvider());
-			Bind<IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider>().ToFactory(() =>
-				new UseFirstArgumentAsNameInstanceProvider(skipFirstArgument: false));
-
-		}
-	}
-}

VECTO3GUI2020/Ninject/IMultistageDependencies.cs

@@ -4,19 +4,19 @@ using TUGraz.VectoCore.InputData.FileIO.XML;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Factory;
 using TUGraz.VectoCore.Utils;
 using VECTO3GUI2020.Helper;
-using VECTO3GUI2020.Util.XML.Interfaces;
+using VECTO3GUI2020.Util.XML;
 using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle.Components;
 
 namespace VECTO3GUI2020.Ninject
 {
-	public interface IMultistageDependencies
+    public interface IMultistageDependencies
 	{
 		Lazy<IDialogHelper> DialogHelperLazy { get; }
 
 		IDialogHelper DialogHelper { get; }
 		IDeclarationInjectFactory InjectFactory { get; }
 		IComponentViewModelFactory ComponentViewModelFactory { get; }
-
+		IXMLComponentInputReader ComponentInputReader { get; }
 		IXMLWriterFactory XMLWriterFactory { get;  }
 	}
 }
\ No newline at end of file

VECTO3GUI2020/Ninject/MultiStageViewModelFactory.cs

-using TUGraz.VectoCommon.InputData;
-using VECTO3GUI2020.ViewModel.Implementation;
-using VECTO3GUI2020.ViewModel.Interfaces.Common;
-using VECTO3GUI2020.ViewModel.Interfaces.Document;
-using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle;
-using VECTO3GUI2020.ViewModel.MultiStage.Implementation;
-using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
-
-namespace VECTO3GUI2020.Ninject
-{
-	public class MultiStageViewModelFactory : IMultiStageViewModelFactory	
-	{
-		private IMultiStageViewModelFactoryDefaultInstanceProvider _multiStageVmFactoryDefaultInstanceProvider;
-		private IMultiStageViewModelFactoryTypeAsNameInstanceProvider _multiStageViewModelFactoryTypeAsNameInstanceProvider;
-
-		private IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider
-			_multistageViewModelFactoryFirstParameterAsNameInstanceProvider;
-
-
-		public MultiStageViewModelFactory(IMultiStageViewModelFactoryDefaultInstanceProvider multiStageVmFactoryDefaultInstanceProvider, 
-			IMultiStageViewModelFactoryTypeAsNameInstanceProvider multiStageViewModelFactoryTypeAsNameInstanceProvider, IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider multistageViewModelFactoryFirstParameterAsNameInstanceProvider)
-		{
-			_multiStageVmFactoryDefaultInstanceProvider = multiStageVmFactoryDefaultInstanceProvider;
-			_multiStageViewModelFactoryTypeAsNameInstanceProvider = multiStageViewModelFactoryTypeAsNameInstanceProvider;
-			_multistageViewModelFactoryFirstParameterAsNameInstanceProvider = multistageViewModelFactoryFirstParameterAsNameInstanceProvider;
-		}
-
-		#region Implementation of IMultiStageViewModelFactoryDefaultInstanceProvider
-
-		public IDocumentViewModel GetStageInputViewModel(bool exemptedVehicle)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetStageInputViewModel(exemptedVehicle);
-		}
-
-		public IViewModelBase GetNewMultistageJobViewModel()
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetNewMultistageJobViewModel();
-		}
-
-		public IMultiStageJobViewModel GetMultiStageJobViewModel(IMultistepBusInputDataProvider inputData)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetMultiStageJobViewModel(inputData);
-		}
-
-		public IVehicleViewModel GetInterimStageVehicleViewModel()
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetInterimStageVehicleViewModel();
-		}
-
-		public IVehicleViewModel GetInterimStageVehicleViewModel(IVehicleDeclarationInputData consolidatedVehicleData, bool exempted)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetInterimStageVehicleViewModel(consolidatedVehicleData, exempted);
-		}
-
-		public IManufacturingStageViewModel GetManufacturingStageViewModel(
-			IManufacturingStageInputData consolidatedManufacturingStageInputData, bool exempted)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetManufacturingStageViewModel(consolidatedManufacturingStageInputData, exempted);
-		}
-
-		public IMultistageAirdragViewModel GetMultistageAirdragViewModel()
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetMultistageAirdragViewModel();
-		}
-
-		public IMultistageAirdragViewModel GetMultistageAirdragViewModel(IAirdragDeclarationInputData consolidatedAirdragInputData)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetMultistageAirdragViewModel(consolidatedAirdragInputData);
-		}
-
-		public IMultistageAuxiliariesViewModel GetAuxiliariesViewModel()
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetAuxiliariesViewModel();
-		}
-
-		public IMultistageAuxiliariesViewModel
-			GetAuxiliariesViewModel(IBusAuxiliariesDeclarationData consolidatedAuxiliariesInputData)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetAuxiliariesViewModel(consolidatedAuxiliariesInputData);
-		}
-
-		public ICreateVifViewModel GetCreateNewVifViewModel(bool completed)
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetCreateNewVifViewModel(completed);
-		}
-
-		public ICreateVifViewModel GetCreateNewVifViewModel()
-		{
-			return _multiStageVmFactoryDefaultInstanceProvider.GetCreateNewVifViewModel();
-		}
-
-		#endregion
-
-		#region Implementation of IMultiStageViewModelFactoryTypeAsNameInstanceProvider
-
-		public IDocumentViewModel CreateDocumentViewModel(IDeclarationInputDataProvider inputData)
-		{
-			return _multiStageViewModelFactoryTypeAsNameInstanceProvider.CreateDocumentViewModel(inputData);
-		}
-
-		public IDocumentViewModel CreateDocumentViewModel(IInputDataProvider inputData)
-		{
-			return _multiStageViewModelFactoryTypeAsNameInstanceProvider.CreateDocumentViewModel(inputData);
-		}
-
-		public IVehicleViewModel CreateStageInputVehicleViewModel(IVehicleDeclarationInputData inputData)
-		{
-			return _multiStageViewModelFactoryTypeAsNameInstanceProvider.CreateStageInputVehicleViewModel(inputData);
-		}
-
-		#endregion
-
-
-		#region Implementation of IMultistageViewModelFactoryFirstParameterAsNameInstanceProvider
-
-		public IVehicleViewModel CreateStageInputVehicleViewModel(string inputProviderType)
-		{
-			return _multistageViewModelFactoryFirstParameterAsNameInstanceProvider.CreateStageInputVehicleViewModel(inputProviderType);
-		}
-
-		#endregion
-	}
-}
\ No newline at end of file

VECTO3GUI2020/Ninject/MultistageLazyDependencies.cs

@@ -3,24 +3,26 @@ using TUGraz.VectoCore.InputData.FileIO.XML;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Factory;
 using TUGraz.VectoCore.Utils;
 using VECTO3GUI2020.Helper;
-using VECTO3GUI2020.Util.XML.Interfaces;
+using VECTO3GUI2020.Util.XML;
 using VECTO3GUI2020.ViewModel.Interfaces.JobEdit.Vehicle.Components;
 using VECTO3GUI2020.ViewModel.MultiStage.Interfaces;
 
 namespace VECTO3GUI2020.Ninject
 {
-	public class MultistageLazyDependencies : IMultistageDependencies
+    public class MultistageLazyDependencies : IMultistageDependencies
 	{
 		private readonly Lazy<IXMLWriterFactory> _xmlWriterFactory;
 		private readonly Lazy<IDeclarationInjectFactory> _injectFactory;
 		private readonly Lazy<IComponentViewModelFactory> _componentViewModelFactory;
 		private readonly Lazy<IMultiStageViewModelFactory> _multistageViewModelFactory;
 		private readonly Lazy<IDialogHelper> _dialogHelper;
+		private readonly Lazy<IXMLComponentInputReader> _componentInputReader;
 		public Lazy<IMultiStageViewModelFactory> MultistageViewModelFactory => _multistageViewModelFactory;
 		public Lazy<IDialogHelper> DialogHelperLazy => _dialogHelper;
 		public IDialogHelper DialogHelper => _dialogHelper.Value;
 		public IDeclarationInjectFactory InjectFactory => _injectFactory.Value;
 		public IComponentViewModelFactory ComponentViewModelFactory => _componentViewModelFactory.Value;
+		public IXMLComponentInputReader ComponentInputReader => _componentInputReader.Value;
 		public IXMLWriterFactory XMLWriterFactory => _xmlWriterFactory.Value;
 
 		public MultistageLazyDependencies(
@@ -28,13 +30,15 @@ namespace VECTO3GUI2020.Ninject
 			Lazy<IDeclarationInjectFactory> injectFactory, 
 			Lazy<IComponentViewModelFactory> componentViewModelFactory,
 			Lazy<IXMLWriterFactory> xmlWriterFactory,
-			Lazy<IMultiStageViewModelFactory> viewModelFactory)
+			Lazy<IMultiStageViewModelFactory> viewModelFactory,
+			Lazy<IXMLComponentInputReader> componentInputReader)
 		{
 			_dialogHelper = dialogHelper;
 			_componentViewModelFactory = componentViewModelFactory;
 			_injectFactory = injectFactory;
 			_xmlWriterFactory = xmlWriterFactory;
 			_multistageViewModelFactory = viewModelFactory;
+			_componentInputReader = componentInputReader;
 		}
 	}
 }
\ No newline at end of file

VECTO3GUI2020/Ninject/MultistageModule.cs

@@ -22,29 +22,15 @@ namespace VECTO3GUI2020.Ninject
 			Bind<IMultiStageJobViewModel>().To<MultiStageJobViewModel_v0_1>().
 				NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetMultiStageJobViewModel(null));
 
-			Bind<IVehicleViewModel>().To<InterimStageBusVehicleViewModel_v2_8>().
-				NamedLikeFactoryMethod((IMultiStageViewModelFactory f)=>f.GetInterimStageVehicleViewModel());
-
 			Bind<IManufacturingStageViewModel>().To<ManufacturingStageViewModel_v0_1>().
 				NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetManufacturingStageViewModel(null, false));
 
 			Bind<IMultistageAirdragViewModel>().To<MultistageAirdragViewModel>().
 				NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetMultistageAirdragViewModel());
 
-			Bind<IMultistageAuxiliariesViewModel>().To<MultistageAuxiliariesViewModel>().
-				NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetAuxiliariesViewModel(null));
 
 			Bind<IMultistageDependencies>().To<MultistageLazyDependencies>();
 
-			Bind<ICreateVifViewModel>().To<CreateVifViewModel>().
-				NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetCreateNewVifViewModel());
-
-			Bind<IDocumentViewModel>().To<StageInputViewModel>()
-				.Named(typeof(XMLDeclarationInputDataProviderV20).ToString());
-
-			Bind<IDocumentViewModel>().To<StageInputViewModel>()
-				.NamedLikeFactoryMethod((IMultiStageViewModelFactory f) => f.GetStageInputViewModel(default(bool)));
-
 			Bind<IAdditionalJobInfoViewModel>().To<AdditionalJobInfoViewModelMultiStage>()
 				.WhenInjectedInto(typeof(IMultiStageJobViewModel));
 

VECTO3GUI2020/Ninject/Vecto3GUI2020Module.cs

 using System.Windows;
 using Ninject.Modules;
+using TUGraz.VectoCore;
 using VECTO3GUI2020.Helper;
 using VECTO3GUI2020.Model.Implementation;
 using VECTO3GUI2020.Model.Interfaces;
@@ -9,12 +10,15 @@ using VECTO3GUI2020.ViewModel.Interfaces;
 
 namespace VECTO3GUI2020.Ninject
 {
-	public class Vecto3GUI2020Module : NinjectModule
+	public class Vecto3GUI2020Module : AbstractNinjectModule
 	{
 		#region Overrides of NinjectModule
 
 		public override void Load()
 		{
+			LoadModule<MultistageModule>();
+
+
 
 			Bind<IJobListViewModel>().To<JobListViewModel>().InSingletonScope();
 			Bind<IMainWindowViewModel>().To<MainWindowViewModel>();