コード例 #1
0
        public long AddAsset(string title, string filename, long folderId, int languageId, long externalTypeid, byte[] filestream, ContentMetaData[] potentialMeta)
        {
            try
            {
                assetManager = new AssetManager();
                assetManager.ContentLanguage = languageId;
                if (string.IsNullOrEmpty(userauthHeader.AuthenticationToken))
                    throw new SoapException("User not logged in", SoapException.ClientFaultCode);

                this.ImpersonateUser(userauthHeader.AuthenticationToken, assetManager.RequestInformation);

                ContentAssetData contentassetdata = new ContentAssetData()
                {
                    FolderId = folderId,
                    Title = title,
                    File = filestream,
                    LanguageId = languageId,
                    ExternalTypeId = externalTypeid,
                    AssetData = new AssetData { FileName = filename },
                    MetaData = potentialMeta
                };

                return assetManager.Add(contentassetdata).Id;
            }
            catch (Exception ex)
            {
                throw new SoapException("Error adding an asset:" + ex.Message, SoapException.ClientFaultCode);
            }
        }
コード例 #2
0
        public ActionResult Create(AssetModel assetModel)
        {
            try
            {
                // create new Asset object from AssetModel
                var asset = new Asset
                {
                    TagNumber   = assetModel.TagNumber,
                    AssetTypeId = assetModel.AssetTypeId,
                    //AssetType = AssetTypeManager.GetAssetTypeById(assetModel.AssetTypeId),
                    Manufacturer = assetModel.Manufacturer,
                    Model        = assetModel.Model,
                    Description  = assetModel.Description,
                    SerialNumber = assetModel.SerialNumber
                };

                // Pass in new Asset object to AssetManager to add into database
                AssetManager.Add(asset);
                return(RedirectToAction("Index"));
            }
            catch
            {
                // simply return if failed
                return(View());
            }
        }
コード例 #3
0
 public IActionResult Create(Asset newAsset)
 {
     try
     {
         AssetManager.Add(newAsset);
         return(RedirectToAction("Index"));
     }
     catch
     {
         return(View());
     }
 }
コード例 #4
0
 public IActionResult Create(Asset asset)
 {
     try
     {
         AssetManager.Add(asset);
         return(RedirectToAction("Search", "Assets"));
     }
     catch
     {
         return(View());
     }
 }
コード例 #5
0
 public IActionResult Create(Asset asset)
 {
     try
     {
         AssetManager.Add(asset);
         return RedirectToAction("Index");
     }
     catch
     {
         return View();
     }
 }
コード例 #6
0
ファイル: AssetController.cs プロジェクト: bingolcl/WebMVC
 public ActionResult Create(Asset asset)
 {
     try
     {
         // TODO: Add insert logic here
         AssetManager.Add(asset);
         return(RedirectToAction(nameof(Index)));
     }
     catch
     {
         return(View("Error"));
     }
 }
コード例 #7
0
        public ActionResult Create(Asset asset)
        {
            try
            {
                // call the Method to add an asset - see Asset manager class
                AssetManager.Add(asset);

                return(RedirectToAction(nameof(Index)));
            }
            catch
            {
                return(View());
            }
        }
コード例 #8
0
ファイル: InfraBuilder.cs プロジェクト: smartpcr/aks-wizard
        public void Build(string manifestFile, string outputFolder)
        {
            IEnumerable <IAsset> unresolvedAssets = null;
            var assets = AssetReader.Read(manifestFile);

            if (assets?.Any() == true)
            {
                foreach (var asset in assets)
                {
                    _assetManager.Add(asset);
                    unresolvedAssets = _assetManager.EvaluateUnfulfilledComponents(asset);
                }
            }

            if (unresolvedAssets?.Any() == true)
            {
                foreach (var asset in unresolvedAssets)
                {
                    _logger.LogWarning($"Unable to resolve {asset.Type}");
                    var missingDependencyTypes = asset.Dependencies.Where(d =>
                                                                          string.IsNullOrEmpty(d.Key))
                                                 .Select(d => d.Type);
                    _logger.LogWarning($"Unresolved components: {string.Join(",", missingDependencyTypes)}");
                }
            }

            if (!Directory.Exists(outputFolder))
            {
                Directory.CreateDirectory(outputFolder);
            }

            var sortedComponents = _assetManager.GetAllAssetsWithObjPath();
            var valueYamlFile    = Path.Combine(outputFolder, "values.yaml");

            if (File.Exists(valueYamlFile))
            {
                _logger.LogInformation(new FileInfo(valueYamlFile).FullName);

                File.Delete(valueYamlFile);
            }

            using (var writer = new StreamWriter(File.OpenWrite(valueYamlFile)))
            {
                foreach (var asset in sortedComponents)
                {
                    asset.WriteYaml(writer, _assetManager, _loggerFactory);
                }
            }
        }
コード例 #9
0
 private void uxOk_Click(object sender, EventArgs e)
 {
     if (Asset == null)
     {
         // doing an insert
         Asset = new Asset();
         SetAsset();
         AssetManager.Add(Asset);
     }
     else
     {
         // doing an update
         SetAsset();
         AssetManager.Update(Asset);
     }
     Close();
 }
コード例 #10
0
 public async Task <IActionResult> Create([Bind("Id,TagNumber,AssetTypeId,Manufacturer,Model,Description,SerialNumber")] Asset asset)
 {
     if (ModelState.IsValid)
     {
         try
         {
             // TODO: Add insert logic here
             AssetManager.Add(asset);
             return(RedirectToAction(nameof(Index)));
         }
         catch
         {
             return(View(asset));
         }
     }
     ViewData["AssetTypeId"] = new SelectList(AssetTypeManager.GetAll(), "Id", "Name", asset.AssetTypeId);
     return(View(asset));
 }
コード例 #11
0
        public IActionResult AddAsset(Asset asset)
        {
            try
            {
                //Attempt to add the new object to the database context.
                AssetManager.Add(asset);
                //If the update is successful, redirect to index.
                return(RedirectToAction("Index"));
            }

            catch
            {
                //If the update fails, reinitialize the asset types DropDownList and return the view.
                var assetTypes = AssetTypeManager.GetAllAssetTypes();
                ViewBag.AssetTypes = assetTypes;
                return(View());
            }
        }
コード例 #12
0
        static void Main()
        {
            RenderWindow window = new RenderWindow(new VideoMode(1000, 500), "BattleShips", Styles.Close, new ContextSettings(16, 0, 4));

            window.Closed += (sender, eventArg) => window.Close();

            LanguageManager.Init("res/lang.json");
            LanguageManager.SetCurrent("pl");

            AssetManager.Add <Font>("Bungee", @"res/fonts/Bungee-Regular.ttf");
            AssetManager.Add <Texture>("SettingsIcon", @"res/img/settingsIcon.png");
            AssetManager.Add <Texture>("PlayIcon", @"res/img/playIcon.png");
            AssetManager.Add <Texture>("PortBackground", @"res/img/portBackground.png");

            InitializeGameStates(window);

            Stopwatch deltaTimer = new Stopwatch();
            float     deltaTime  = 0;

            while (window.IsOpen)
            {
                deltaTime += deltaTimer.ElapsedMilliseconds;
                deltaTimer.Restart();
                if (deltaTime > 1000 / 60)
                {
                    deltaTime /= 1000;
                    GameStates.GameStateManager.DeltaTime = deltaTime;
                    GameStates.GameStateManager.Update(window);
                    deltaTime = 0;
                }
                window.DispatchEvents();

                GameStates.GameStateManager.Show(window);
                window.Display();

                deltaTimer.Stop();
            }
        }
コード例 #13
0
        public IActionResult Create(AssetViewModel newAssetMV)
        {
            var newAsset = new Asset()
            {
                Id           = newAssetMV.Id,
                TagNumber    = newAssetMV.TagNumber,
                AssetTypeId  = newAssetMV.AssetTypeId,
                Manufacturer = newAssetMV.Manufacturer,
                Model        = newAssetMV.Model,
                Description  = newAssetMV.Description,
                SerialNumber = newAssetMV.SerialNumber
            };

            try
            {
                AssetManager.Add(newAsset);
                return(RedirectToAction("Index", "Home"));
            }
            catch
            {
                return(View());
            }
        }
コード例 #14
0
        /// <summary>
        /// Creates the asset.
        /// </summary>
        /// <param name="assetViewModel">The asset view model.</param>
        public void CreateAsset(CreateAssetViewModel createAssetViewModel, string uploadPath, int companyId)
        {
            try
            {
                AssetViewModel assetviewModel = AssetViewModelFactory.CreateAssetViewModelFromCreateAssetViewModel(createAssetViewModel, uploadPath, companyId, FileManager);

                if (assetviewModel.AssetType == 1)
                {
                    if (IsYoutubeVideo(assetviewModel))
                    {
                        assetviewModel = embedYoutubeVideo(assetviewModel);
                    }
                }


                Asset asset = AssetViewModelFactory.CreateFromViewModelModel(assetviewModel, ObjectMapper);
                AssetManager.Add(asset);
            }
            catch (Exception ex)
            {
                ExceptionManager.HandleException(ex, PolicyNameType.ExceptionReplacing);
            }
        }
コード例 #15
0
        public void GenerateCode(string manifestFile, string solutionFolder)
        {
            IEnumerable <IAsset> unresolvedAssets = null;
            var assets = AssetReader.Read(manifestFile);

            if (assets?.Any() == true)
            {
                foreach (var asset in assets)
                {
                    _assetManager.Add(asset);
                    unresolvedAssets = _assetManager.EvaluateUnfulfilledComponents(asset);
                }
            }

            if (unresolvedAssets?.Any() == true)
            {
                foreach (var asset in unresolvedAssets)
                {
                    _logger.LogWarning($"Unable to resolve {asset.Type}");
                    var missingDependencyTypes = asset.Dependencies.Where(d =>
                                                                          string.IsNullOrEmpty(d.Key))
                                                 .Select(d => d.Type);
                    _logger.LogWarning($"Unresolved components: {string.Join(",", missingDependencyTypes)}");
                }
            }

            var sortedComponents = _assetManager.GetAllAssetsWithObjPath()
                                   .Where(c => c.Kind == AssetKind.Code || c.Kind == AssetKind.Shared)
                                   .OrderBy(c => c.SortOrder)
                                   .ToList();
            var validator = new AssetValidator(_assetManager, _loggerFactory);

            validator.TryToValidateAssets(sortedComponents);

            // update solution file
            var product = _assetManager.Get(AssetType.Prodct) as Product;

            if (product == null)
            {
                throw new Exception("Missing dependency [Product]");
            }
            var defaultSolutionFile = Path.Join(solutionFolder, $"{product.Name}.sln");

            if (sortedComponents.FirstOrDefault(c => c.Type == AssetType.Service) is Services services)
            {
                foreach (var service in services.Items.OfType <Service>())
                {
                    service.SolutionFile = service.SolutionFile ?? defaultSolutionFile;
                }
            }

            if (!Directory.Exists(solutionFolder))
            {
                Directory.CreateDirectory(solutionFolder);
            }
            var zipFilePath = Path.Join("Evidence", "solution.zip");

            if (!File.Exists(zipFilePath))
            {
                throw new Exception($"Unable to find solution bundle: {new FileInfo(zipFilePath).FullName}");
            }
            ZipFile.ExtractToDirectory(zipFilePath, solutionFolder, true);
            var solutionFile = Directory.GetFiles(solutionFolder, "*.sln", SearchOption.TopDirectoryOnly)
                               .FirstOrDefault();

            if (!string.IsNullOrEmpty(solutionFile))
            {
                File.Copy(solutionFile, defaultSolutionFile, true);
                File.Delete(solutionFile);
            }

            var manifestYamlFile = Path.Combine(solutionFolder, "services.yaml");

            _logger.LogInformation($"Set manifest file to '{new FileInfo(manifestYamlFile).FullName}'");
            if (File.Exists(manifestYamlFile))
            {
                File.Delete(manifestYamlFile);
            }

            using (var writer = new StreamWriter(File.OpenWrite(manifestYamlFile)))
            {
                foreach (var asset in sortedComponents)
                {
                    asset.WriteYaml(writer, _assetManager, _loggerFactory);
                }
            }

            // replace "True" and "False"
            var yamlContent = File.ReadAllText(manifestYamlFile);
            var trueRegex   = new Regex("\\bTrue\\b");

            yamlContent = trueRegex.Replace(yamlContent, "true");
            var falseRegex = new Regex("\\bFalse\\b");

            yamlContent = falseRegex.Replace(yamlContent, "false");
            File.WriteAllText(manifestYamlFile, yamlContent);
        }
コード例 #16
0
ファイル: GameEngine.cs プロジェクト: randomcrab/SE
        private void LoadEngineContent()
        {
            EngineContent = new ContentLoader(Content.ServiceProvider, "EngineContent", "Data/_MAIN/Content/");
            if (Screen.IsFullHeadless)
            {
                return;
            }

            // Particle shader.
            AssetManager.Add(new AssetBuilder <Effect>()
                             .ID("testshader")
                             .Create(new GeneralContentProcessor <Effect>("EngineContent", "shader"))
                             .FromContent(EngineContent)
                             );

            // Texture2Ds
            AssetManager.Add(new AssetBuilder <Texture2D>()
                             .ID("tileset")
                             .Create(new GeneralContentProcessor <Texture2D>("EngineContent", "Images/tileset"))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <Texture2D>()
                             .ID("UI")
                             .Create(new GeneralContentProcessor <Texture2D>("EngineContent", "UI"))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <Texture2D>()
                             .ID("EditorUI")
                             .Create(new GeneralContentProcessor <Texture2D>("EngineContent", "EditorUI"))
                             .FromContent(EngineContent)
                             );

            // Sprite Textures
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("uiRect")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 0, 64, 64)))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("leveleditorcursor")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 64, 64, 64)))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("debugsmallsquare")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 128, 16, 16)))
                             .FromContent(EngineContent)
                             );

            // Sprite Fonts
            AssetManager.Add(new AssetBuilder <SpriteFont>()
                             .ID("editor")
                             .Create(new GeneralContentProcessor <SpriteFont>("EngineContent", "fonts/editor"))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <SpriteFont>()
                             .ID("editor_subheading")
                             .Create(new GeneralContentProcessor <SpriteFont>("EngineContent", "fonts/editor"))
                             .FromContent(EngineContent)
                             );
            AssetManager.Add(new AssetBuilder <SpriteFont>()
                             .ID("editor_heading")
                             .Create(new GeneralContentProcessor <SpriteFont>("EngineContent", "fonts/editor_heading"))
                             .FromContent(EngineContent)
                             );
        }
コード例 #17
0
 public void Add_NullAsset_ThrowsException()
 {
     _assetManager.Add(null, null);
 }
コード例 #18
0
        protected override void LoadAssets()
        {
            base.LoadAssets();
            content = new ContentLoader(Content.ServiceProvider, "Content1", "Data/_MAIN/Content");
            ContentLoader content2 = new ContentLoader(Content.ServiceProvider, "Content2", "Data/_MAIN/Content");

            if (!Screen.IsFullHeadless)
            {
                AssetManager.Add(new AssetBuilder <Texture2D>()
                                 .ID("tileset2")
                                 .Create(new GeneralContentProcessor <Texture2D>("Content1", "Images/tileset2"))
                                 .FromContent(content2)
                                 );

                AssetManager.Add(new AssetBuilder <Texture2D>()
                                 .ID("Smoke")
                                 .Create(new GeneralContentProcessor <Texture2D>("Content1", "Images/Smoke"))
                                 .FromContent(content)
                                 );
            }

            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("unload_test")
                             .Create(new SpriteTextureProcessor("tileset2", new Rectangle(0, 0, 64, 64)))
                             .FromContent(content2)
                             );

            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("floor")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 0, 64, 64)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("wall_down")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(64, 48, 64, 16)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("wall_left")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(128, 0, 16, 64)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("wall_right")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(240, 0, 16, 64)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("wall_up")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(256, 0, 64, 16)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("player")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 0, 52, 52)))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <SpriteTexture>()
                             .ID("circle")
                             .Create(new SpriteTextureProcessor("tileset", new Rectangle(0, 128, 32, 32)))
                             .FromContent(content)
                             );

            if (!Screen.IsFullHeadless)
            {
                AssetManager.Add(new AssetBuilder <SoundEffect>()
                                 .ID("assaultrifle")
                                 .Create(new GeneralContentProcessor <SoundEffect>("Content1", "assaultrifle"))
                                 .FromContent(content)
                                 );
            }

            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("0")
                             .Create(new TileProcessor(pos => {
                Floor obj = new Floor(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.White;
                return(obj);
            }))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("1")
                             .Create(new TileProcessor(pos => {
                WallUp obj = new WallUp(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.Red;
                return(obj);
            }))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("2")
                             .Create(new TileProcessor(pos => {
                WallRight obj = new WallRight(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.Blue;
                return(obj);
            }))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("3")
                             .Create(new TileProcessor(pos => {
                WallDown obj = new WallDown(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.Orange;
                return(obj);
            }))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("4")
                             .Create(new TileProcessor(pos => {
                WallLeft obj = new WallLeft(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.Purple;
                return(obj);
            }))
                             .FromContent(content)
                             );
            AssetManager.Add(new AssetBuilder <Func <Vector2, GameObject> >()
                             .ID("5")
                             .Create(new TileProcessor(pos => {
                AnimatedFloor obj = new AnimatedFloor(pos, 0f, Vector2.One);
                obj.GetComponent <Sprite>().Color = Color.White;
                return(obj);
            }))
                             .FromContent(content)
                             );

            //for (int i = 0; i < 50; i++) {
            //    Database.Add<int, Func<Vector2, GameObject>>(6+i, pos => {
            //        AnimatedFloor obj = new AnimatedFloor(pos, 0f, Vector2.One);
            //        //obj.GetComponent<Sprite>().Color = Color.White;
            //        return obj;
            //    });
            //}
        }
コード例 #19
0
        public string GetAssetContentQuickLink(string filename, string title, int languageid, long contentid, long folderid, byte[] filestream)
        {
            if (string.IsNullOrEmpty(userauthHeader.AuthenticationToken))
                throw new SoapException("User not logged in", SoapException.ClientFaultCode);

            assetManager = new AssetManager();
            assetManager.ContentLanguage = languageid;
            this.ImpersonateUser(userauthHeader.AuthenticationToken, assetManager.RequestInformation);

            if (contentid > 0)
            {
                ContentAssetData contentassetdata = assetManager.GetItem(contentid, true);

                if (contentassetdata == null)
                    throw new SoapException("Error Updating Asset", SoapException.ClientFaultCode);

                contentassetdata.Title = title;
                contentassetdata.File = filestream;
                contentassetdata.AssetData.FileName = filename;
                contentassetdata.LanguageId = languageid;

                return assetManager.GetItem((assetManager.Update(contentassetdata).Id)).Quicklink;
            }
            else
            {
                ContentAssetData contentassetdata = new ContentAssetData()
                {
                    FolderId = folderid,
                    Title = title,
                    File = filestream,
                    LanguageId = languageid,
                    AssetData = new AssetData { FileName = filename }
                };

                return assetManager.GetItem((assetManager.Add(contentassetdata).Id)).Quicklink;
            }
        }
コード例 #20
0
        public void BuildInfraSetupScript(string manifestFile, string outputFolder)
        {
            IEnumerable <IAsset> unresolvedAssets = null;
            var assets = AssetReader.Read(manifestFile);

            if (assets?.Any() == true)
            {
                foreach (var asset in assets)
                {
                    _assetManager.Add(asset);
                    unresolvedAssets = _assetManager.EvaluateUnfulfilledComponents(asset);
                }
            }

            if (unresolvedAssets?.Any() == true)
            {
                foreach (var asset in unresolvedAssets)
                {
                    _logger.LogWarning($"Unable to resolve {asset.Type}");
                    var missingDependencyTypes = asset.Dependencies.Where(d =>
                                                                          string.IsNullOrEmpty(d.Key))
                                                 .Select(d => d.Type);
                    _logger.LogWarning($"Unresolved components: {string.Join(",", missingDependencyTypes)}");
                }
            }

            var sortedComponents = _assetManager.GetAllAssetsWithObjPath()
                                   .Where(c => c.Kind == AssetKind.Infra || c.Kind == AssetKind.Shared)
                                   .OrderBy(c => c.SortOrder)
                                   .ToList();
            var validator = new AssetValidator(_assetManager, _loggerFactory);

            validator.TryToValidateAssets(sortedComponents);
            var envName   = "dev";
            var spaceName = Environment.UserName;

            if (sortedComponents.FirstOrDefault(c => c.Type == AssetType.Global) is Global global)
            {
                envName   = global.EnvName;
                spaceName = global.SpaceName;
            }

            if (!Directory.Exists(outputFolder))
            {
                Directory.CreateDirectory(outputFolder);
            }
            var envFolder = Path.Join(outputFolder, "env", envName);

            if (!Directory.Exists(envFolder))
            {
                Directory.CreateDirectory(envFolder);
            }

            var spaceFolder = envFolder;

            if (!string.IsNullOrEmpty(spaceName))
            {
                spaceFolder = Path.Join(envFolder, spaceName);
            }
            if (!Directory.Exists(spaceFolder))
            {
                Directory.CreateDirectory(spaceFolder);
            }

            var zipFilePath = Path.Join("Evidence", "scripts.zip");

            if (!File.Exists(zipFilePath))
            {
                throw new Exception($"Unable to find script bundle: {new FileInfo(zipFilePath).FullName}");
            }
            ZipFile.ExtractToDirectory(zipFilePath, outputFolder, true);

            var valueYamlFile = Path.Combine(spaceFolder, "values.yaml");

            _logger.LogInformation($"Set values yaml file to '{new FileInfo(valueYamlFile).FullName}'");
            if (File.Exists(valueYamlFile))
            {
                File.Delete(valueYamlFile);
            }

            using (var writer = new StreamWriter(File.OpenWrite(valueYamlFile)))
            {
                foreach (var asset in sortedComponents)
                {
                    asset.WriteYaml(writer, _assetManager, _loggerFactory);
                }
            }

            // replace "True" and "False"
            var yamlContent = File.ReadAllText(valueYamlFile);
            var trueRegex   = new Regex("\\bTrue\\b");

            yamlContent = trueRegex.Replace(yamlContent, "true");
            var falseRegex = new Regex("\\bFalse\\b");

            yamlContent = falseRegex.Replace(yamlContent, "false");
            File.WriteAllText(valueYamlFile, yamlContent);
        }