private (ApiModule requestApiModule, ApiModule responseApiModule) GetExistingOrCreateNewApiModulePair(
            TCObject objectToExecuteOn,
            XTestStep wseTestStep,
            IWseArtifactsParser wseParser)
        {
            ApiModule requestApiModule  = null;
            ApiModule responseApiModule = null;

            if (!IsModuleSearchCriteriaEmpty(wseParser))
            {
                (requestApiModule, responseApiModule) =
                    CommonUtilities.SearchExistingApiModule(objectToExecuteOn, wseParser, wseTestStep);
            }

            if (requestApiModule != null)
            {
                return(requestApiModule, responseApiModule);
            }

            FolderStructureHandler folderStructureHandler = new FolderStructureHandler();

            (TCFolder apiModuleFolder, string moduleName) =
                folderStructureHandler.CreateFolderForApiModules(objectToExecuteOn, wseTestStep, wseParser);
            return(ApiModuleHandler.CreateApiModulePair(apiModuleFolder, moduleName, wseParser));
        }
        /// <summary>
        /// Migrates the Wse Module and all referencing XTestSteps.
        /// </summary>
        /// <param name="objectToExecuteOn">Only WSE XTestSteps and XModules which are present under this object will be migrated.</param>
        public void Migrate(TCObject objectToExecuteOn)
        {
            var wseTestSteps = CommonUtilities.GetFilteredWseTestSteps(objectToExecuteOn, wseModule.TestSteps);

            if (!wseTestSteps.Any())
            {
                WseModuleParser wseParser = new WseModuleParser();
                wseParser.Parse(wseModule);
                FolderStructureHandler folderStructureHandler = new FolderStructureHandler();
                TCFolder apiModuleFolder = folderStructureHandler.CreateFolderForApiModules(wseModule);
                ApiModuleHandler.CreateApiModulePair(apiModuleFolder, wseModule.Name, wseParser);
            }
            else
            {
                foreach (var wseTestStep in wseTestSteps)
                {
                    WseTestStepParser wseTestStepParser = new WseTestStepParser();
                    wseTestStepParser.Parse(wseTestStep, new XmlPayloadParser());
                    (ApiModule requestApiModule, ApiModule responseApiModule) =
                        GetExistingOrCreateNewApiModulePair(objectToExecuteOn, wseTestStep, wseTestStepParser);

                    WseTestStepMigrator wseTestStepMigrator = new WseTestStepMigrator();
                    wseTestStepMigrator.Migrate(objectToExecuteOn,
                                                requestApiModule,
                                                responseApiModule,
                                                new XmlPayloadParser(),
                                                new XmlPayloadSetterFactory(),
                                                wseTestStep);
                }
            }
        }
        public void CreateApiModulesAndTestSteps(TCObject rootComponentFolder,
                                                 XModule wseModule,
                                                 ModuleType moduleType)
        {
            foreach (var teststep in CommonUtilities.GetFilteredWseTestSteps(rootComponentFolder, wseModule.TestSteps))
            {
                try {
                    var requestSpecializationModule = teststep.TestStepValues
                                                      .FirstOrDefault(
                        x => x.Name == "Request" &&
                        (x.SpecializationModule.Name
                         != "Web service request data in JSON Resource" &&
                         x.SpecializationModule.Name
                         != "Web service request data in XML Resource"
                        ))
                                                      ?.SpecializationModule;

                    var responseSpecializationModule = teststep.TestStepValues
                                                       .FirstOrDefault(
                        x => x.Name == "Response" &&
                        (x.SpecializationModule.Name
                         != "Web service response data in JSON Resource" &&
                         x.SpecializationModule.Name
                         != "Web service response data in XML Resource"
                        ))
                                                       ?.SpecializationModule;

                    if (responseSpecializationModule == null && requestSpecializationModule == null)
                    {
                        return;
                    }
                    string correlationId  = Guid.NewGuid().ToString();
                    var    testStepParser = new WseTestStepParser(moduleType);
                    testStepParser.Parse(teststep, requestSpecializationModule, responseSpecializationModule);
                    ApiModule requestApiModule;
                    ApiModule responseApiModule;
                    ApiModule apiModule = null;
                    switch (moduleType)
                    {
                    case ModuleType.CommunicatewithWebserviceRestJson
                        when !string.IsNullOrEmpty(testStepParser.Endpoint):
                    case ModuleType.CommunicatewithWebservice
                        when !string.IsNullOrEmpty(CommonUtilities.GetSoapAction(testStepParser.Headers)):
                        apiModule = SearchApiModuleByScanTag(rootComponentFolder,
                                                             testStepParser,
                                                             requestSpecializationModule,
                                                             responseSpecializationModule,
                                                             SearchRequestModule);
                        break;
                    }

                    if (apiModule == null)
                    {
                        var apiModuleFolder =
                            new FolderStructureHandler().CreateFolderForWseModules(
                                rootComponentFolder,
                                requestSpecializationModule ?? responseSpecializationModule);
                        requestApiModule =
                            ApiModuleCreator.CreateRequestModule(apiModuleFolder,
                                                                 requestSpecializationModule == null
                                                                             ? responseSpecializationModule.Name
                                                                             : requestSpecializationModule.Name,
                                                                 testStepParser,
                                                                 correlationId,
                                                                 ScanTag.GetRequestScanTag(testStepParser));
                        string responseModuleName = requestSpecializationModule == null
                                                            ? responseSpecializationModule.Name
                                                            : requestSpecializationModule.Name;
                        responseApiModule =
                            ApiModuleCreator.CreateResponseModule(apiModuleFolder,
                                                                  $"{responseModuleName} Response",
                                                                  testStepParser,
                                                                  correlationId,
                                                                  ScanTag.GetResponseScanTag(testStepParser));
                    }
                    else
                    {
                        requestApiModule  = apiModule;
                        responseApiModule = SearchApiModuleByScanTag(rootComponentFolder,
                                                                     testStepParser,
                                                                     requestSpecializationModule,
                                                                     responseSpecializationModule,
                                                                     SearchResponseModule);
                    }

                    FileLogger.Instance.Debug(
                        $"Completed migration for WSE Module : '{wseModule.Name}' NodePath:'{wseModule.NodePath}'");

                    WseTestStepImporter wseTestStepMigrator = new WseTestStepImporter();
                    wseTestStepMigrator.MigrateTestSteps(rootComponentFolder,
                                                         requestApiModule,
                                                         responseApiModule,
                                                         new List <XTestStep>()
                    {
                        teststep
                    },
                                                         moduleType);
                }
                catch (Exception e) {
                    FileLogger.Instance.Error(e);
                }
            }
        }