Esempio n. 1
0
        private async Task GetInstalledTerminalsAsync(TerminalFileModel model)
        {
            var terminalDefs = new Dictionary <Terminal, bool>();

            terminalDefs.Add(new Terminal()
            {
                Name      = "Windows Terminal",
                Path      = "wt.exe",
                Arguments = "-d .",
                Icon      = ""
            }, await IsWindowsTerminalBuildInstalled());

            terminalDefs.Add(new Terminal()
            {
                Name      = "Fluent Terminal",
                Path      = "flute.exe",
                Arguments = "",
                Icon      = ""
            }, await PackageHelper.IsAppInstalledAsync("53621FSApps.FluentTerminal_87x1pks76srcp"));

            terminalDefs.Add(new Terminal()
            {
                Name      = "CMD",
                Path      = "cmd.exe",
                Arguments = "",
                Icon      = ""
            }, true);    // CMD will always be present (for now at least)

            terminalDefs.Where(x => x.Value).ForEach(x => model.AddTerminal(x.Key));
            terminalDefs.Where(x => !x.Value).ForEach(x => model.RemoveTerminal(x.Key));
        }
Esempio n. 2
0
        private async Task LoadAsync()
        {
            StorageFolder Folder = await FilesystemTasks.Wrap(() => ApplicationData.Current.LocalFolder.CreateFolderAsync("settings", CreationCollisionOption.OpenIfExists).AsTask());

            if (Folder == null)
            {
                Model = await GetDefaultTerminalFileModel();

                return;
            }

            var JsonFile = await FilesystemTasks.Wrap(() => Folder.GetFileAsync(JsonFileName).AsTask());

            if (!JsonFile)
            {
                if (JsonFile == FileSystemStatusCode.NotFound)
                {
                    Model = await GetDefaultTerminalFileModel();

                    SaveModel();
                    return;
                }
                else
                {
                    Model = await GetDefaultTerminalFileModel();

                    return;
                }
            }

            try
            {
                var content = await FileIO.ReadTextAsync(JsonFile.Result);

                Model = JsonConvert.DeserializeObject <TerminalFileModel>(content);
                if (Model == null)
                {
                    throw new JsonParsingNullException(JsonFileName);
                }
            }
            catch (JsonParsingNullException)
            {
                Model = await GetDefaultTerminalFileModel();

                SaveModel();
            }
            catch (Exception)
            {
                Model = await GetDefaultTerminalFileModel();
            }
        }
Esempio n. 3
0
        private async Task Load()
        {
            Folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("settings", CreationCollisionOption.OpenIfExists);

            try
            {
                JsonFile = await Folder.GetFileAsync(JsonFileName);
            }
            catch (FileNotFoundException)
            {
                var defaultFile = StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));

                JsonFile = await Folder.CreateFileAsync(JsonFileName);

                await FileIO.WriteBufferAsync(JsonFile, await FileIO.ReadBufferAsync(await defaultFile));
            }

            var content = await FileIO.ReadTextAsync(JsonFile);

            try
            {
                Model = JsonConvert.DeserializeObject <TerminalFileModel>(content);
                if (Model == null)
                {
                    Model = new TerminalFileModel();
                    throw new JsonParsingNullException(JsonFileName);
                }
            }
            catch (JsonParsingNullException)
            {
                var defaultFile = StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));

                JsonFile = await Folder.CreateFileAsync(JsonFileName, CreationCollisionOption.ReplaceExisting);

                await FileIO.WriteBufferAsync(JsonFile, await FileIO.ReadBufferAsync(await defaultFile));

                var defaultContent = await FileIO.ReadTextAsync(JsonFile);

                Model = JsonConvert.DeserializeObject <TerminalFileModel>(defaultContent);
            }
            catch (Exception)
            {
                var defaultFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));

                JsonFile = null;
                var defaultContent = await FileIO.ReadTextAsync(defaultFile);

                Model = JsonConvert.DeserializeObject <TerminalFileModel>(defaultContent);
            }
        }
Esempio n. 4
0
        private async Task <TerminalFileModel> GetDefaultTerminalFileModel()
        {
            try
            {
                StorageFile defaultFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));

                var defaultContent = await FileIO.ReadTextAsync(defaultFile);

                var model = JsonConvert.DeserializeObject <TerminalFileModel>(defaultContent);
                await GetInstalledTerminalsAsync(model);

                model.ResetToDefaultTerminal();
                return(model);
            }
            catch
            {
                var model = new TerminalFileModel();
                await GetInstalledTerminalsAsync(model);

                model.ResetToDefaultTerminal();
                return(model);
            }
        }
Esempio n. 5
0
        private async Task <TerminalFileModel> GetDefaultTerminalFileModel()
        {
            try
            {
                StorageFile defaultFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(defaultTerminalPath));

                var defaultContent = await FileIO.ReadTextAsync(defaultFile);

                return(JsonConvert.DeserializeObject <TerminalFileModel>(defaultContent));
            }
            catch
            {
                var model = new TerminalFileModel();
                model.Terminals.Add(new Terminal()
                {
                    Name      = "CMD",
                    Path      = "cmd.exe",
                    Arguments = "",
                    Icon      = ""
                });
                model.ResetToDefaultTerminal();
                return(model);
            }
        }
Esempio n. 6
0
 public TerminalController()
 {
     Model = new TerminalFileModel();
 }