public int InstallTestSuite(string name, string packageName, Stream package, string description)
        {
            var extractNode = ExtractPackage(packageName, package, StoragePool);
            var version     = GetTestSuiteVersion(extractNode);

            if (!CheckTestSuiteVersion(version))
            {
                extractNode.DeleteNode();
                throw new NotSupportedException($"PTMService only supports version {TestSuiteConsts.SupportedMinVersion} or above version, you could try use PTMGUI to run previous versions");
            }

            using var instance = ScopedServiceFactory.GetInstance();

            var pool = instance.ScopedServiceInstance;

            var repo = pool.Get <TestSuiteInstallation>();

            var testSuiteInstallation = new TestSuiteInstallation
            {
                Name          = name,
                InstallMethod = TestSuiteInstallMethod.UploadPackage,
                Description   = description,
                Version       = version
            };

            try
            {
                repo.Insert(testSuiteInstallation);

                pool.Save().Wait();

                int id            = testSuiteInstallation.Id;
                var testSuiteNode = StoragePool.GetKnownNode(KnownStorageNodeNames.TestSuite).CreateNode(id.ToString());
                testSuiteNode.CopyFromNode(extractNode, true);
                testSuiteInstallation.Path = testSuiteNode.AbsolutePath;

                var testSuite = TestSuite.Create(Options.TestEnginePath, testSuiteInstallation, testSuiteNode);

                repo.Update(testSuiteInstallation);
                pool.Save().Wait();

                TestSuitePool.AddOrUpdate(id, _ => testSuite, (_, _) => testSuite);

                return(id);
            }
            catch
            {
                repo.Remove(testSuiteInstallation);
                pool.Save().Wait();

                throw;
            }
        }
        private string CreateProfile(ProfileExportRequest request)
        {
            List <TestCase> testCases = new List <TestCase>();

            var configurationNode = StoragePool.GetKnownNode(KnownStorageNodeNames.Configuration);

            var testSuite = GetTestSuite(request.TestSuiteId);

            using (ProfileUtil profile = ProfileUtil.CreateProfile(
                       request.FileName, testSuite.Name, testSuite.Version))
            {
                string configBasePath    = GetConfigurationsPath(request.ConfigurationId, configurationNode.AbsolutePath);
                string profileSourceFile = Path.Combine(configBasePath, ConfigurationConsts.Profile);

                ProfileUtil.FileToStream(profileSourceFile, profile.ProfileStream);

                string ptfConfigSourceDir = GetPtfConfigBasePath(request.ConfigurationId, configurationNode.AbsolutePath);

                string[] ptfConfigFiles = Directory.GetFiles(ptfConfigSourceDir, "*.ptfconfig", SearchOption.TopDirectoryOnly);

                foreach (string settingsConfigFile in ptfConfigFiles)
                {
                    profile.AddPtfCfg(settingsConfigFile);
                }


                if (request.SelectedTestCases != null)
                {
                    foreach (var testCaseName in request.SelectedTestCases)
                    {
                        var testCase = new TestCase()
                        {
                            FullName  = testCaseName,
                            IsChecked = true
                        };

                        testCases.Add(testCase);
                    }
                }

                ExportPlaylist(profile.PlaylistStream, true, request.TestResultId, testCases);
            }

            return(request.FileName);
        }
        /// <summary>
        /// Loads the configurations from a saved profile.
        /// </summary>
        /// <param name="request">Profile request.</param>
        public void LoadProfileSettings(ProfileRequest request)
        {
            string filenameWithoutExtension = Path.GetFileNameWithoutExtension(request.FileName);

            var baseNode = StoragePool.GetKnownNode(KnownStorageNodeNames.TestSuite);

            if (baseNode.NodeExists(filenameWithoutExtension))
            {
                baseNode.RemoveNode(filenameWithoutExtension);
            }

            var profileNode = baseNode.CreateNode(filenameWithoutExtension);

            profileNode.CreateFile(request.FileName, request.Stream);

            string fullName = Path.Combine(profileNode.AbsolutePath, request.FileName);

            var configurationNode = StoragePool.GetKnownNode(KnownStorageNodeNames.Configuration);

            var testSuite = GetTestSuite(request.TestSuiteId);

            using (ProfileUtil profile = ProfileUtil.LoadProfile(fullName))
            {
                if (!profile.VerifyVersion(testSuite.Version))
                {
                    if (profile.Info != null)
                    {
                        throw new InvalidDataException(string.Format
                                                       (
                                                           StringMessages.ProfileNotMatchError,
                                                           profile.Info.TestSuiteName,
                                                           profile.Info.Version,
                                                           testSuite.Name,
                                                           testSuite.Version
                                                       )
                                                       );
                    }
                    else
                    {
                        throw new InvalidDataException(StringMessages.InvalidProfile);
                    }
                }

                string configBaseNode = GetConfigurationsPath(request.ConfigurationId, configurationNode.AbsolutePath);

                if (!configurationNode.NodeExists(configBaseNode))
                {
                    configurationNode.CreateNode(configBaseNode);
                }

                string profileDestinationPath  = Path.Combine(configBaseNode, ConfigurationConsts.Profile);
                string playlistDestinationPath = Path.Combine(configBaseNode, ConfigurationConsts.PlayList);

                configurationNode.RemoveFile(profileDestinationPath);
                configurationNode.RemoveFile(playlistDestinationPath);

                configurationNode.CreateFile(profileDestinationPath, profile.ProfileStream);
                configurationNode.CreateFile(playlistDestinationPath, profile.PlaylistStream);

                string ptfConfigsDestinationDir = GetPtfConfigBasePath(request.ConfigurationId, configurationNode.AbsolutePath);

                profile.SavePtfCfgTo(ptfConfigsDestinationDir);
            }
        }