/// <summary> /// Removes the specified script. /// </summary> /// <param name="scriptName">Name of script to remove.</param> public void RemoveScript(String scriptName) { // Cannot create an autoscript from the client. if (isAutoScript(scriptName)) { throw new StackHashException("Cannot remove system scripts", StackHashServiceErrorCode.CannotRemoveSystemScripts); } String fileName = getScriptFileName(scriptName); // Load it to see if it is read only. if (File.Exists(fileName)) { StackHashScriptSettings script = StackHashScriptSettings.Load(fileName); if (!script.IsReadOnly) { File.Delete(fileName); } else { throw new StackHashException("Cannot remove Read Only script", StackHashServiceErrorCode.CannotRemoveSystemScripts); } } }
public void UpdateScriptFile() { bool saveAutoScript = false; bool fileExists = File.Exists(m_ScriptFileName); if (fileExists) { // Load in the script and check the version number. If there is an error during load // then just create a new copy of the file. try { StackHashScriptSettings thisScript = StackHashScriptSettings.Load(m_ScriptFileName); saveAutoScript = !IsScriptCurrent(thisScript); } catch (System.Exception ex) { String message = String.Format(CultureInfo.InvariantCulture, "Failed to load script {0} - Reconstructing", ScriptName); DiagnosticsHelper.LogException(DiagSeverity.Warning, message, ex); saveAutoScript = true; } } else { saveAutoScript = true; } FileAttributes currentAttributes; if (saveAutoScript) { if (fileExists) { currentAttributes = File.GetAttributes(m_ScriptFileName); // Turn off the readonly permission so the file can be updated. if ((currentAttributes & FileAttributes.ReadOnly) != 0) { // Clear the read only flag. File.SetAttributes(m_ScriptFileName, currentAttributes & ~FileAttributes.ReadOnly); } } StackHashScriptSettings autoScript = GenerateScript(); autoScript.Save(m_ScriptFileName); } // Make sure the file is marked read only so the client can't delete it. currentAttributes = File.GetAttributes(m_ScriptFileName); if ((currentAttributes & FileAttributes.ReadOnly) == 0) { // Set the read only flag. File.SetAttributes(m_ScriptFileName, currentAttributes | FileAttributes.ReadOnly); } }
/// <summary> /// Gets all script contexts. /// </summary> /// <returns>Full list of all the script settings.</returns> private StackHashScriptCollection GetAllScripts() { StackHashScriptCollection allScripts = new StackHashScriptCollection(); String [] allScriptFiles = Directory.GetFiles(m_ScriptFolder, s_ScriptWildcard); foreach (String fileName in allScriptFiles) { StackHashScriptSettings thisScript = StackHashScriptSettings.Load(fileName); allScripts.Add(thisScript); } return(allScripts); }
private void scriptSaveLoadNCommands(int numCommands, bool addComment) { StackHashScript script = new StackHashScript(); for (int i = 0; i < numCommands; i++) { String command = "command" + i.ToString(); String comment = null; if (addComment) { comment = "comment" + i.ToString(); } script.Add(new StackHashScriptLine(command, comment)); } String testScriptName = m_TempPath + "\\scriptsettings.wds"; StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script); scriptSettings.Name = "TestName"; scriptSettings.CreationDate = DateTime.Now.ToUniversalTime(); scriptSettings.LastModifiedDate = DateTime.Now.ToUniversalTime(); scriptSettings.Owner = StackHashScriptOwner.System; scriptSettings.RunAutomatically = true; scriptSettings.Version = 2; scriptSettings.Save(testScriptName); // And load in again and compare. StackHashScriptSettings loadedSettings = StackHashScriptSettings.Load(testScriptName); Assert.AreEqual(scriptSettings.CreationDate, loadedSettings.CreationDate); Assert.AreEqual(scriptSettings.LastModifiedDate, loadedSettings.LastModifiedDate); Assert.AreEqual(scriptSettings.Name, loadedSettings.Name); Assert.AreEqual(scriptSettings.Script.Count, loadedSettings.Script.Count); Assert.AreEqual(scriptSettings.RunAutomatically, loadedSettings.RunAutomatically); Assert.AreEqual(scriptSettings.Version, loadedSettings.Version); Assert.AreEqual(scriptSettings.Owner, loadedSettings.Owner); for (int i = 0; i < scriptSettings.Script.Count; i++) { Assert.AreEqual(scriptSettings.Script[i].Command, loadedSettings.Script[i].Command); Assert.AreEqual(scriptSettings.Script[i].Comment, loadedSettings.Script[i].Comment); } }
/// <summary> /// Loads the specified script file. /// </summary> /// <param name="scriptName">Script to load.</param> /// <returns>The script settings.</returns> public StackHashScriptSettings LoadScript(string scriptName, bool noException) { String fileName = getScriptFileName(scriptName); if (!File.Exists(fileName)) { if (noException) { return(null); } else { throw new StackHashException("Script file does not exist when loading script.", StackHashServiceErrorCode.ScriptDoesNotExist); } } StackHashScriptSettings newScriptSettings = StackHashScriptSettings.Load(fileName); return(newScriptSettings); }
/// <summary> /// Renames the specified script. /// </summary> /// <param name="oldScriptName">Current name of the script.</param> /// <param name="newScriptName">New name of the script.</param> public void RenameScript(String oldScriptName, String newScriptName) { if (string.IsNullOrEmpty(oldScriptName)) { throw new ArgumentNullException("oldScriptName"); } if (string.IsNullOrEmpty(newScriptName)) { throw new ArgumentNullException("newScriptName"); } // Don't do anything if the name hasn't changed. if (oldScriptName == newScriptName) { return; } String fileName = getScriptFileName(oldScriptName); if (!File.Exists(fileName)) { throw new StackHashException("Script name does not exist during rename", StackHashServiceErrorCode.ScriptDoesNotExist); } // Load in the script and save it to the new name. StackHashScriptSettings thisScript = StackHashScriptSettings.Load(fileName); thisScript.Name = newScriptName; thisScript.LastModifiedDate = DateTime.Now.ToUniversalTime(); String newFileName = getScriptFileName(newScriptName); thisScript.Save(newFileName); // Delete the old script as the renamed version is now available. File.Delete(fileName); }
/// <summary> /// Add a new script. /// </summary> /// <param name="script">Full script settings.</param> /// <param name="overwrite">true - Overwrite any old script of the same name.</param> /// <param name="allowReadOnlyScriptOverwrite">true - allow read only script to be overwritten.</param> public void AddScript(StackHashScriptSettings script, bool overwrite, bool allowReadOnlyScriptOverwrite) { if (script == null) { throw new ArgumentNullException("script"); } String fileName = getScriptFileName(script.Name); if (File.Exists(fileName)) { if (!overwrite) { throw new StackHashException("Script file already exists and overWrite not set", StackHashServiceErrorCode.CannotOverwriteScriptFile); } else { // File already exists. The Created time should remain the same. The update time should change. StackHashScriptSettings oldScript = StackHashScriptSettings.Load(fileName); if (oldScript.IsReadOnly && !allowReadOnlyScriptOverwrite) { throw new InvalidOperationException("Cannot overwrite Read Only script"); } script.CreationDate = oldScript.CreationDate; script.LastModifiedDate = DateTime.Now.ToUniversalTime(); } } else { script.CreationDate = DateTime.Now.ToUniversalTime(); script.LastModifiedDate = script.CreationDate; } script.Save(fileName); }