public void WriteAll(string fileName)
{
XmlTextWriter writer = new XmlTextWriter(fileName, Encoding.UTF8);
writer.WriteStartDocument();
writer.Formatting = Formatting.Indented;
writer.Indentation = 1;
writer.IndentChar = '\t';
writer.WriteStartElement("configuration");
writer.WriteStartElement(PHP.Core.Configuration.SectionName);
// write libraries:
if (Extensions.Count > 0)
{
writer.WriteStartElement("classLibrary");
foreach (DictionaryEntry entry in Extensions)
{
PhpLibraryDescriptor descriptor = (PhpLibraryDescriptor)entry.Key;
writer.WriteStartElement("add");
writer.WriteAttributeString("assembly", descriptor.RealAssembly.FullName);
// TODO: writer.WriteAttributeString("section", descriptor.Name);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
// writes Core options and removes them from hashtable:
PhpIni.CoreOptionsToXml(writer, Options, phpNames);
// writes BCL options and removes them from hashtable:
writer.WriteStartElement("bcl");
LibraryConfiguration.LegacyOptionsToXml(writer, Options, phpNames);
writer.WriteEndElement();
// distributes remaining options to extensions buckets:
DistributeExtensionOptions();
// write extension options:
ExtensionOptionsToXml(writer);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
if (Options.Count > 0)
{
string[] opt_names = new string[Options.Count];
Options.Keys.CopyTo(opt_names, 0);
Array.Sort(opt_names);
Console.Error.WriteLine("Following options has been skipped. They are either not supported or the declaring extension is not loaded by the .ini file.");
foreach (string option in opt_names)
{
Console.Error.WriteLine(option);
}
}
}
private void Init_Window()
{
try
{
WriteProgress("Setting console colors..", 30);
if (LibraryConfiguration.IsNotNull("SetColors"))
{
if (LibraryConfiguration.IsTrue("SetColors"))
{
InvokeScript(string.Format("$host.UI.RawUI.ForegroundColor = \"{0}\"", LibraryConfiguration.IsNotNull("ForegroundColor") ? LibraryConfiguration.Setting <string>("ForegroundColor") : "White"));
InvokeScript(string.Format("$host.UI.RawUI.BackgroundColor = \"{0}\"", LibraryConfiguration.IsNotNull("BackgroundColor") ? LibraryConfiguration.Setting <string>("BackgroundColor") : "DarkBlue"));
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process ConsoleColors, error: {0}", ex.Message));
}
try
{
WriteProgress("Disabling window control box..", 35);
if (LibraryConfiguration.IsNotNull("DisableControlBox"))
{
if (LibraryConfiguration.IsTrue("DisableControlBox"))
{
InvokeScript("Disable-WindowControlBox");
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process ControlBox, error: {0}", ex.Message));
}
}
private void Init_Prompt()
{
try
{
WriteProgress("Setting up prompt..", 25);
if (LibraryConfiguration.IsNotNull("ReplacePrompt"))
{
if (LibraryConfiguration.IsTrue("ReplacePrompt"))
{
InvokeScript((string)Resources.General.Prompt);
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process Prompt, error: {0}", ex.Message));
}
}
private void Init_Banner()
{
try
{
WriteProgress("Finishing touches..", 95);
if (LibraryConfiguration.IsNotNull("PrintBanner"))
{
if (LibraryConfiguration.IsTrue("PrintBanner"))
{
Version vInfo = Assembly.GetExecutingAssembly().GetName().Version;
InvokeScript("Clear-Host");
InvokeScript(string.Format("Write-Host \"Sorlov PowerShell Utilities (v{0}.{1}.{2}.{3})\" -ForegroundColor White", vInfo.Major, vInfo.Minor, vInfo.Build, vInfo.Revision));
InvokeScript("Write-Host \"Copyright (C) 2010-2017 by Daniel Sörlöv \" -ForegroundColor White");
InvokeScript("Write-Host \"All rights reserved. Freeware version.\" -ForegroundColor White");
InvokeScript("Write-Host");
InvokeScript("Write-Host");
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process PrintBanner, error: {0}", ex.Message));
}
}
//public const string settingsFileName = "appsettings.config";
//private const int settingVersion = 3;
//private XmlSettingManager<ApplicationSettings> SettingsXml { get; set; }
//private ApplicationSettings Settings { get; set; }
//private string GetOldLibraryDirectory()
//{
// var dir = System.Environment.GetFolderPath
// (Environment.SpecialFolder.LocalApplicationData);
//
// var saveDirectory =
// Path.Combine(dir, @"Packages\60037Boredbone.MikanViewer_8weh06aq8rfkj\LocalState");
//
// return saveDirectory;
//}
public async Task ConvertOldLibraryAsync
(string saveDirectory, string settingFileName, string oldLibraryDirectory, int settingVersion)
{
if (saveDirectory == null || settingFileName == null || oldLibraryDirectory == null)
{
return;
}
Console.WriteLine($"Loading...");
var config = new LibraryConfiguration(saveDirectory)
{
Concurrency = 512,
FileTypeFilter = new HashSet <string>(),
FileSystem = new FileSystem(),
};
LibraryOwner.SetConfig(config);
using (var library = LibraryOwner.GetCurrent())
{
library.InitSettings();
await library.LoadAsync();
//ストレージに保存する設定
var settingsXml = new XmlSettingManager <ApplicationSettings>
(Path.Combine(saveDirectory, settingFileName));
var settings = settingsXml
.LoadXml(XmlLoadingOptions.IgnoreAllException | XmlLoadingOptions.UseBackup)
.Value;
using (var locking = await library.LockAsync())
{
//var saveDirectory = this.GetOldLibraryDirectory();
var converter = new LibraryConverter.Compat.Converter();
await converter.Start1(oldLibraryDirectory, settings);
var data = library.GetDataForConvert();
var count = 0;
await converter.Start2(data.Item1, data.Item2, data.Item3,
x => count = x, x =>
{
Console.CursorLeft = 0;
Console.Write($"Importing {x} / {count}");
});
Console.WriteLine("");
library.SaveSettings();
}
try
{
settings.Version = settingVersion;
settingsXml.SaveXml(settings);
}
catch
{
}
}
}
public bool Initialize(string saveDirectory)
{
// Set the user interface to display in the same culture as that set in Control Panel.
System.Threading.Thread.CurrentThread.CurrentUICulture =
System.Threading.Thread.CurrentThread.CurrentCulture;
//ストレージに保存する設定
this.SettingsXml = new XmlSettingManager <ApplicationSettings>
(Path.Combine(saveDirectory, settingsFileName));
this.Settings = SettingsXml
.LoadXml(XmlLoadingOptions.IgnoreAllException | XmlLoadingOptions.UseBackup)
.Value;
this.ImageBuffer = new ImageBuffer().AddTo(this.Disposables);
this.ImageBuffer.MetaImageExtention = this.MetaImageExtention;
var config = new LibraryConfiguration(saveDirectory)
{
Concurrency = 512,
FileTypeFilter = new HashSet <string>(this.FileTypeFilter),
FileSystem = new FileSystem(),
};
LibraryOwner.SetConfig(config);
var library = LibraryOwner.GetCurrent();
library.InitSettings();
library.LoadAsync().Wait();
library.AddTo(this.Disposables);
this.Library = library;
this.LibraryUpdateHistory = new ReactiveCollection <LibraryUpdateHistoryItem>().AddTo(this.Disposables);
this.Library.Loaded
.Subscribe(x => this.LibraryUpdateHistory.AddRangeOnScheduler(
x.AddedFiles.Select(y => new LibraryUpdateHistoryItem()
{
Date = x.DateTime, Path = y.Key, Type = LibraryUpdateType.Add
})
.Concat(x.RemovedFiles.Select(y => new LibraryUpdateHistoryItem()
{
Date = x.DateTime, Path = y.Key, Type = LibraryUpdateType.Remove
}))
.Concat(x.UpdatedFiles.Select(y => new LibraryUpdateHistoryItem()
{
Date = x.DateTime, Path = y.Key, Type = LibraryUpdateType.Update
}))))
.AddTo(this.Disposables);
this.SystemNotification = this.Library.Loaded
.Select(x => this.ShowLibraryResult(x))
.Where(x => x != null)
.Publish().RefCount();
//リソースから文字列を取得
this.InitializeResourceString();
//色テーマ
this.ObserveProperty(x => x.IsDarkTheme)
.Subscribe(x =>
{
((App)Application.Current).ChangeTheme(x ? darkThemeName : lightThemeName);
})
.AddTo(this.Disposables);
this.ObserveProperty(x => x.BackgroundColor)
.Subscribe(x =>
{
Application.Current.Resources["BasicBackColor"] = new SolidColorBrush(x);
})
.AddTo(this.Disposables);
this.isChanged = true;
this.PropertyChangedAsObservable().Subscribe(x => this.isChanged = true).AddTo(this.Disposables);
var libraryHasItem = this.Library.HasItems();
//ライブラリ更新
if (libraryHasItem && this.RefreshLibraryOnLaunched)
{
this.Library.StartRefreshLibrary(false);
}
return(libraryHasItem);
}
public LibraryActor(IOptionsMonitor <LibraryConfiguration> config, IBassActor bass)
{
Config = config.CurrentValue;
bassActor = bass ?? throw new ArgumentNullException(nameof(bass));
buildLibrary(bass);
}
protected override void BeginProcessing()
{
string pathName = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "WindowsPowershell\\Modules\\Sorlov.PowerShell");
base.BeginProcessing();
WriteProgress("Initializing..", 0);
WriteProgress("Creating configuration..", 10);
XmlDocument xmlDocument = new XmlDocument();
XmlNode xmlRoot = xmlDocument.CreateNode(XmlNodeType.Element, "PSState", "");
xmlDocument.AppendChild(xmlRoot);
if (LibraryConfiguration.IsTrue("PersistPath"))
{
WriteProgress("General settings..", 20);
XmlNode xmlGeneral = CreateXmlNode(xmlRoot, "General");
CreateXmlNode(xmlGeneral, "Pwd", CreateSimpleDictionary("Value", SessionState.Path.CurrentLocation.ProviderPath));
}
if (LibraryConfiguration.IsTrue("PersistHistory"))
{
WriteProgress("History..", 30);
List <PSObject> history = SessionState.InvokeCommand.InvokeScript("Get-History -Count 100").ToList <PSObject>();
XmlNode xmlHistory = CreateXmlNode(xmlRoot, "HistoryList");
foreach (PSObject historyObject in history)
{
Dictionary <string, string> props = CreateSimpleDictionary("Id", historyObject.Properties["Id"].Value.ToString());
props.Add("CommandLine", historyObject.Properties["CommandLine"].Value.ToString());
props.Add("ExecutionStatus", historyObject.Properties["ExecutionStatus"].Value.ToString());
props.Add("StartExecutionTime", historyObject.Properties["StartExecutionTime"].Value.ToString());
props.Add("EndExecutionTime", historyObject.Properties["EndExecutionTime"].Value.ToString());
CreateXmlNode(xmlHistory, "History", props);
}
}
if (LibraryConfiguration.IsTrue("PersistAliases"))
{
SessionStateAliasEntry[] aliasInfo = typeof(System.Management.Automation.Runspaces.InitialSessionState).GetProperty("BuiltInAliases", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, new object[0]) as SessionStateAliasEntry[];
Dictionary <string, SessionStateAliasEntry> builtInAliases = new Dictionary <string, SessionStateAliasEntry>();
foreach (SessionStateAliasEntry entry in aliasInfo)
{
builtInAliases.Add(entry.Name.ToLower(), entry);
}
WriteProgress("Aliases..", 50);
XmlNode xmlAlias = CreateXmlNode(xmlRoot, "AliasList");
List <PSObject> alias = SessionState.InvokeCommand.InvokeScript("Get-Alias").ToList <PSObject>();
foreach (PSObject aliasObject in alias)
{
if (!builtInAliases.ContainsKey(aliasObject.Properties["Name"].Value.ToString().ToLower()))
{
Dictionary <string, string> props = CreateSimpleDictionary("Name", aliasObject.Properties["Name"].Value.ToString());
props.Add("Definition", aliasObject.Properties["Definition"].Value.ToString());
CreateXmlNode(xmlAlias, "Alias", props);
}
}
}
WriteProgress("Saving..", 90);
string savePath = System.IO.Path.Combine(pathName, "Sorlov.PowerShell.PersistedState.xml");
xmlDocument.Save(savePath);
WriteProgress("Done", 100);
}
private void Init_PersistedData(string pathName)
{
try
{
WriteProgress("Restoring data..", 50);
string configFile = System.IO.Path.Combine(pathName, "Sorlov.PowerShell.PersistedState.xml");
if (System.IO.File.Exists(configFile))
{
WriteProgress("Loading persisted state..", 55);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(configFile);
try
{
if (LibraryConfiguration.IsNotNull("PersistPath"))
{
if (LibraryConfiguration.IsTrue("PersistPath"))
{
WriteProgress("Processing general items..", 60);
XmlNode pwdNode = xmlDoc.SelectSingleNode("/PSState/General/Pwd");
InvokeScript(string.Format("Set-Location \"{0}\"", pwdNode.Attributes["Value"].Value));
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process PersistPath, error: {0}", ex.Message));
}
try
{
if (LibraryConfiguration.IsNotNull("PersistHistory"))
{
if (LibraryConfiguration.IsTrue("PersistHistory"))
{
WriteProgress("Restoring history..", 65);
int id = 0;
string historyFile = "@'" + Environment.NewLine;
historyFile += "#TYPE Microsoft.PowerShell.Commands.HistoryInfo" + Environment.NewLine;
historyFile += "\"Id\",\"CommandLine\",\"ExecutionStatus\",\"StartExecutionTime\",\"EndExecutionTime\"" + Environment.NewLine;
XmlNodeList history = xmlDoc.SelectNodes("/PSState/HistoryList/History");
foreach (XmlNode historyNode in history)
{
historyFile += string.Format("\"{0}\",\"{1}\",\"{2}\",\"{3}\",\"{4}\"" + Environment.NewLine, historyNode.Attributes["Id"].Value, historyNode.Attributes["CommandLine"].Value, historyNode.Attributes["ExecutionStatus"].Value, historyNode.Attributes["StartExecutionTime"].Value, historyNode.Attributes["EndExecutionTime"].Value);
id++;
}
historyFile += "'@ | ConvertFrom-CSV | Add-History";
InvokeScript(historyFile);
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process PersistHistory, error: {0}", ex.Message));
}
try
{
if (LibraryConfiguration.IsNotNull("PersistAliases"))
{
if (LibraryConfiguration.IsTrue("PersistAliases"))
{
WriteProgress("Restoring Aliases..", 75);
XmlNodeList aliases = xmlDoc.SelectNodes("/PSState/AliasList/Alias");
foreach (XmlNode alias in aliases)
{
InvokeScript(string.Format("Set-Alias -Name {0} -Value {1} -Scope Global -Force -ErrorAction SilentlyContinue", alias.Attributes["Name"].Value, alias.Attributes["Definition"].Value));
}
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process PersistAliases, error: {0}", ex.Message));
}
}
}
catch (Exception ex)
{
WriteWarning(string.Format("Could not process StateRestore, error: {0}", ex.Message));
}
}
