public ConDepNoRunbookTierDefinedException(Runbook application, ConDepSettings settings)
: base(string.Format("No Tiers defined for application {0}. You need to specify a tier using the {1} attribute on the {0} class. Tiers available in your configuration are {2}.",
application.GetType().Name,
typeof(TierAttribute).Name,
string.Join(", ", settings.Config.Tiers.Select(x => x.Name))))
{
}
public Runbook CreateRunbookByPath(string automationAccountName, string runbookPath, string description, string[] tags)
{
Runbook runbook = this.CreateRunbook(automationAccountName, File.OpenRead(runbookPath));
this.UpdateRunbook(automationAccountName, runbook.Id, description, tags, null, null, null);
return(this.GetRunbook(automationAccountName, runbook.Id));
}
public async Task UpdateTARunbookAsync(Runbook taRunbook)
{
var requestUrl = this.CreateRequestUri(RunPowerShellClient.AdminTARunbooks);
var response = await this.httpClient.PutAsJsonAsync <Runbook>(requestUrl.ToString(), taRunbook);
response.EnsureSuccessStatusCode();
}
public ConDepNoRunbookTierDefinedException(Runbook application, ConDepSettings settings)
: base(string.Format("No Tiers defined for application {0}. You need to specify a tier using the {1} attribute on the {0} class. Tiers available in your configuration are {2}.",
application.GetType().Name,
typeof(TierAttribute).Name,
string.Join(", ", settings.Config.Tiers.Select(x => x.Name))))
{
}
private RunbookDefinition UpdateRunbookDefinition(string automationAccountName, Guid runbookId, Stream runbookStream, bool overwrite)
{
var runbook = new Runbook(this.GetRunbookModel(automationAccountName, runbookId, false));
if (runbook.DraftRunbookVersionId.HasValue && overwrite == false)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyHasDraft));
}
Guid draftRunbookVersionId = runbook.DraftRunbookVersionId.HasValue
? runbook.DraftRunbookVersionId.Value
: this.EditRunbook(automationAccountName, runbook.Id);
var getRunbookDefinitionResponse = this.automationManagementClient.RunbookVersions.GetRunbookDefinition(
automationAccountName,
draftRunbookVersionId.ToString());
this.automationManagementClient.RunbookVersions.UpdateRunbookDefinition(
automationAccountName,
new AutomationManagement.Models.RunbookVersionUpdateRunbookDefinitionParameters
{
ETag = getRunbookDefinitionResponse.ETag,
RunbookVersionId = draftRunbookVersionId.ToString(),
RunbookStream = runbookStream,
});
IEnumerable <RunbookDefinition> runbookDefinitions = this.ListRunbookDefinitionsByRunbookVersionId(automationAccountName, draftRunbookVersionId, true);
return(runbookDefinitions.First());
}
public static IAsyncResult BeginStartRunbook(this Runbook runbook, OrchestratorApi orchestratorApi, AsyncCallback callback, object state, List <NameValuePair> jobParameters = null)
{
return(ActionExtensions.BeginRunbookAction <Guid>(runbook, orchestratorApi, "Start", callback, state, new OperationParameter[]
{
new BodyOperationParameter("parameters", jobParameters)
}));
}
public bool HasDependenciesDefined(Runbook artifact)
{
var typeName = typeof(IDependOn <>).Name;
var interfaces = artifact.GetType().GetInterfaces();
return(interfaces.Any(x => x.Name == typeName));
}
private static void ValidateApplicationTier(Runbook runbook, ConDepSettings settings)
{
var hasTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Any();
if (!hasTier) throw new ConDepNoRunbookTierDefinedException(runbook, settings);
var hasSingleTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).SingleOrDefault() != null;
if (!hasSingleTier) throw new ConDepNoRunbookTierDefinedException(String.Format("Multiple tiers defined for {0}. Only one tier is allowed by Artifact.", runbook.GetType().Name));
}
public TARunbookModel(Runbook taRunbook)
{
this.RunbookId = taRunbook.RunbookId;
this.RunbookName = taRunbook.RunbookName;
this.RunbookTag = taRunbook.RunbookTag;
this.PlanId = taRunbook.PlanId;
this.PlanName = taRunbook.PlanName;
this.Type = "TARunbook";
}
protected override void AutomationExecuteCmdlet()
{
Runbook runbook = null;
// ByRunbookName
runbook = this.AutomationClient.CreateRunbookByName(
this.ResourceGroupName, this.AutomationAccountName, this.Name, this.Description, this.Tags, this.Type, this.LogProgress, this.LogVerbose, false);
this.WriteObject(runbook);
}
public void UpdateRunbook(Runbook runbook)
{
AutomationClient.Runbook.Update(ResourceGroup, AutomationAccount, runbook.Name, new RunbookUpdateParameters
{
Name = runbook.Name,
Description = runbook.Description,
LogProgress = runbook.LogProgress,
LogVerbose = runbook.LogVerbose
});
}
/// <summary>
/// Start Runbook with the the given Runbook and list of NameValuepair parameters
/// </summary>
/// <param name="runbook"></param>
/// <param name="parameters"></param>
/// <returns></returns>
private RunbookJob StartRunBook(Runbook runbook, List <NameValuePair> parameters)
{
//try
//{
IgnoreCertificate();
#region Setting up parameters for runbook
OperationParameter operationParameters = new BodyOperationParameter(JobParameterName, parameters);
#endregion Setting up parameters for runbook
ValidateParameters(runbook, parameters);
#region Create runbook job
// Format the uri
var uri = string.Concat(api.Runbooks, string.Format("(guid'{0}')/{1}", runbook.RunbookID, StartRunbookActionName));
var uriSMA = new Uri(uri, UriKind.Absolute);
var jobIdValue = api.Execute <Guid>(uriSMA, HttpPost, true, operationParameters) as QueryOperationResponse <Guid>;
var jobId = jobIdValue.Single();
var job = api.Jobs.Where(j => j.JobID == jobId).First();
if (job == null)
{
return(new RunbookJob {
OutputMessage = "Job not started!"
});
}
else
{
return(new RunbookJob {
Id = jobId, OutputMessage = String.Format("Job Started. JobID: {0}, JobStatus: {1}", jobId, job.JobStatus)
});
}
#endregion Create runbook job
// }
//catch (DataServiceQueryException ex)
//{
// throw new ApplicationException("Error starting runbook.", ex);
//}
}
public Runbook CreateRunbookByName(string automationAccountName, string runbookName, string description, string[] tags)
{
var runbookScript = string.Format(CultureInfo.InvariantCulture, @"workflow {0}{1}{{{1}}}", runbookName, Environment.NewLine);
using (var streamReader = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(runbookScript), false), Encoding.UTF8))
{
Stream runbookStream = streamReader.BaseStream;
Runbook runbook = this.CreateRunbook(automationAccountName, runbookStream);
this.UpdateRunbook(automationAccountName, runbook.Id, description, tags, null, null, null);
return(this.GetRunbook(automationAccountName, runbook.Id));
}
}
public void UpdateRunbook(Runbook runbook)
{
AutomationClient.Runbooks.Update(automationAccount, new RunbookUpdateParameters
{
Name = runbook.Name,
Properties = new RunbookUpdateProperties
{
Description = runbook.Properties.Description,
LogProgress = runbook.Properties.LogProgress,
LogVerbose = runbook.Properties.LogVerbose
}
});
}
public void UpdateRunbook(Runbook runbook)
{
AutomationClient.Runbooks.Patch(resourceGroup, automationAccount, new RunbookPatchParameters
{
Name = runbook.Name,
Properties = new RunbookPatchProperties
{
Description = runbook.Properties.Description,
LogProgress = runbook.Properties.LogProgress,
LogVerbose = runbook.Properties.LogVerbose
}
});
}
private IEnumerable <RunbookParameter> ListRunbookParameters(string automationAccountName, Guid runbookId)
{
Runbook runbook = this.GetRunbook(automationAccountName, runbookId);
if (!runbook.PublishedRunbookVersionId.HasValue)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.RunbookHasNoPublishedVersionById, runbookId));
}
return(this.automationManagementClient.RunbookParameters.ListByRunbookVersionId(
automationAccountName,
runbook.PublishedRunbookVersionId.Value.ToString()).RunbookParameters.Select(runbookParameter => new RunbookParameter(runbookParameter)));
}
//Runbook exists both on disk and in the cloud. But are they in sync?
public AutomationRunbook(FileInfo localFile, Runbook cloudRunbook, RunbookDraft cloudRunbookDraft)
: base(cloudRunbook.Name, localFile.LastWriteTime, cloudRunbook.Properties.LastModifiedTime.LocalDateTime)
{
this.AuthoringState = cloudRunbook.Properties.State;
this.localFileInfo = localFile;
this.Description = cloudRunbook.Properties.Description;
this.Parameters = cloudRunbook.Properties.Parameters;
if (cloudRunbookDraft != null)
{
this.LastModifiedCloud = cloudRunbookDraft.LastModifiedTime.LocalDateTime;
UpdateSyncStatus();
}
}
/// <summary>
/// validating parameters of Runbook
/// </summary>
/// <param name="runbook"></param>
/// <param name="parameters"></param>
private void ValidateParameters(Runbook runbook, List <NameValuePair> parameters)
{
var pamts = GetRunbookParameters(runbook.PublishedRunbookVersionID) as IEnumerable <SMARunbookParameter>;
var lstErrors = new List <ParameterError>();
foreach (var val in parameters)
{
var param = pamts.Where(p => p.Name == val.Name).FirstOrDefault();
if (param == null)
{
lstErrors.Add(new ParameterError
{
Parameter = new SMARunbookParameter {
Name = val.Name, Value = val.Value
},
ErrorMessage = "Parameter does not exist."
});
}
else
{
var type = Type.GetType(param.Type);
var result = ConvertType(val.Value, type);
if (param.Type == "System.Management.Automation.SwitchParameter")
{
result = val.Value;
}
if (result == null)
{
lstErrors.Add(new ParameterError
{
Parameter = new SMARunbookParameter {
Name = val.Name, Value = val.Value
},
ErrorMessage = String.Format("This parameter expects value of type {0}.The passed value cannot be converted to {0}."
, param.Type)
});
}
}
}
if (lstErrors.Count > 0)
{
throw new ParameterException(lstErrors);
}
}
/// <summary>
/// Return RunbookGenerated type with common properties and parameter definitions. Resource Group Name and Automation Account Name specified from user input (ex. directly in URL)
/// </summary>
public async Task <IRunbookGenerated> GetRunbookGenerated(string resourceGroupName, string automationAccountName, string runbookName)
{
//Get runbook
Runbook runbook = await GetRunbook(resourceGroupName, automationAccountName, runbookName);
var runbookGenerated = new RunbookGenerated
{
Name = runbookName,
DisplayName = runbook.Tags.Where(tag => tag.Key == _automationTagDisplayName.Key).FirstOrDefault().Value,
HybridWorkerGroup = runbook.Tags.Where(tag => tag.Key == _automationTagHybridWorkerGroup.Key).FirstOrDefault().Value,
ParameterDefinitions = await GetRunbookParameterDefinitions(resourceGroupName, automationAccountName, runbook)
};
return(runbookGenerated);
}
private static void ValidateApplicationTier(Runbook runbook, ConDepSettings settings)
{
var hasTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Any();
if (!hasTier)
{
throw new ConDepNoRunbookTierDefinedException(runbook, settings);
}
var hasSingleTier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).SingleOrDefault() != null;
if (!hasSingleTier)
{
throw new ConDepNoRunbookTierDefinedException(String.Format("Multiple tiers defined for {0}. Only one tier is allowed by Artifact.", runbook.GetType().Name));
}
}
private static IAsyncResult BeginRunbookAction <TElement>(Runbook runbook, OrchestratorApi orchestratorApi, string action, AsyncCallback callback, object state, params OperationParameter[] operationParameters)
{
if (runbook == null || runbook.RunbookID == Guid.Empty)
{
throw new ArgumentNullException("runbook");
}
if (orchestratorApi == null)
{
throw new ArgumentNullException("orchestratorApi");
}
if (!ActionExtensions.RunbookActions.Contains(action))
{
throw new ArgumentOutOfRangeException("action", action, "An invalid Runbook action was requested.");
}
return(orchestratorApi.BeginExecute <TElement>(ActionExtensions.GetActionUri(orchestratorApi.Runbooks.RequestUri, runbook.RunbookID, action), callback, state, "POST", true, operationParameters));
}
public IEnumerable<ServerConfig> GetServers(Runbook runbook, ConDepSettings settings)
{
if (settings.Config.UsingTiers)
{
ValidateApplicationTier(runbook, settings);
var tier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Single() as TierAttribute;
if (!settings.Config.Tiers.Exists(tier.TierName))
{
throw new ConDepTierDoesNotExistInConfigException(string.Format("Tier {0} does not exist in {1}.env.config", tier.TierName, settings.Options.Environment));
}
return
settings.Config.Tiers.Single(x => x.Name.Equals(tier.TierName, StringComparison.OrdinalIgnoreCase))
.Servers;
}
return settings.Config.Servers;
}
private static Runbook GetRunbookByPath(string serviceURL, string path)
{
Runbook runbook = null;
SCOService.OrchestratorContext context =
new SCOService.OrchestratorContext(new Uri(serviceURL));
// Set credentials to default or a specific user.
context.Credentials = System.Net.CredentialCache.DefaultCredentials;
// Get the runbook based on the entered path
runbook = context.Runbooks.Where(rb =>
{
return(rb.Path == path);
}).First();
return(runbook);
}
public IEnumerable <ServerConfig> GetServers(Runbook runbook, ConDepSettings settings)
{
if (settings.Config.UsingTiers)
{
ValidateApplicationTier(runbook, settings);
var tier = runbook.GetType().GetCustomAttributes(typeof(TierAttribute), false).Single() as TierAttribute;
if (!settings.Config.Tiers.Exists(tier.TierName))
{
throw new ConDepTierDoesNotExistInConfigException(string.Format("Tier {0} does not exist in {1}.env.config", tier.TierName, settings.Options.Environment));
}
return
(settings.Config.Tiers.Single(x => x.Name.Equals(tier.TierName, StringComparison.OrdinalIgnoreCase))
.Servers);
}
return(settings.Config.Servers);
}
public static IAsyncResult BeginStartOnSchedule(this Runbook runbook, OrchestratorApi orchestratorApi, AsyncCallback callback, object state, Schedule schedule, List <NameValuePair> jobParameters = null)
{
if (schedule == null)
{
throw new ArgumentNullException("schedule");
}
if (schedule.ScheduleID == Guid.Empty)
{
orchestratorApi.AddToSchedules(schedule);
orchestratorApi.SaveChanges();
}
return(ActionExtensions.BeginRunbookAction <Guid>(runbook, orchestratorApi, "StartOnSchedule", callback, state, new OperationParameter[]
{
new BodyOperationParameter("parameters", jobParameters),
new BodyOperationParameter("scheduleId", schedule.ScheduleID)
}));
}
protected override void AutomationProcessRecord()
{
Runbook runbook = null;
// ByRunbookName
runbook = this.AutomationClient.CreateRunbookByName(
this.ResourceGroupName,
this.AutomationAccountName,
this.Name,
this.Description,
this.Tags,
RunbookTypeSdkValue.Resolve(this.Type),
this.LogProgress,
this.LogVerbose,
false);
this.WriteObject(runbook);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileServerModel" /> class.
/// </summary>
/// <param name="ProductModel">The domain name from API.</param>
public RunbookModel(Runbook runbookFromApi)
{
this.RunbookId = runbookFromApi.RunbookId;
this.RunbookName = runbookFromApi.RunbookName;
this.RunbookTag = runbookFromApi.RunbookTag;
this.LastJobStatus = runbookFromApi.LastJobStatus;
this.LastJobStart = runbookFromApi.LastJobStart;
this.PlanId = runbookFromApi.PlanId;
this.PlanName = runbookFromApi.PlanName;
this.SubscriptionId = runbookFromApi.SubscriptionId;
this.ParamString = runbookFromApi.ParamString;
this.ParamInt = runbookFromApi.ParamInt;
this.ParamStringArray = runbookFromApi.ParamStringArray;
this.ParamDate = runbookFromApi.ParamDate;
this.ParamBool = runbookFromApi.ParamBool;
this.ParamVMs = runbookFromApi.ParamVMs;
this.Type = "Runbook";
}
//public void PopulateWithDependencies(Runbook runbook, ConDepSettings settings)
//{
// if (!HasDependenciesDefined(runbook)) return;
// runbook.Dependencies = GetDependeciesForRunbook(runbook, settings);
//}
public List<Runbook> GetDependeciesForRunbook(Runbook runbook, ConDepSettings settings)
{
var typeName = typeof(IDependOn<>).Name;
var typeInterfaces = runbook.GetType().GetInterfaces();
var dependencies = typeInterfaces.Where(x => x.Name == typeName);
var dependencyInstances = new List<Runbook>();
foreach (var infraInterface in dependencies)
{
var dependencyType = infraInterface.GetGenericArguments().Single();
var dependencyInstance = settings.Options.Assembly.CreateInstance(dependencyType.FullName) as Runbook;
dependencyInstances.AddRange(new RunbookDependencyHandler().GetDependeciesForRunbook(dependencyInstance, settings));
dependencyInstances.Add(dependencyInstance);
}
return dependencyInstances;
}
protected override void AutomationExecuteCmdlet()
{
Runbook runbook = null;
if (this.ParameterSetName == AutomationCmdletParameterSets.ByPath)
{
// ByRunbookPath
runbook = this.AutomationClient.CreateRunbookByPath(
this.AutomationAccountName, this.ResolvePath(this.Path), this.Description, this.Tags);
}
else if (this.ParameterSetName == AutomationCmdletParameterSets.ByRunbookName)
{
// ByRunbookName
runbook = this.AutomationClient.CreateRunbookByName(
this.AutomationAccountName, this.Name, this.Description, this.Tags);
}
this.WriteObject(runbook);
}
// main program
static void Main(string[] args)
{
// Begin change values
string serviceURL = "http://*****:*****@"\4.DTEK PROJECTS\LAUNCH-TEST\CS-LAUNCH01";
Hashtable parameters = new Hashtable();
parameters["recipient"] = "*****@*****.**";
parameters["message"] = "Launched CSLAUNCH01 runbook";
// End change values
Runbook runbook = GetRunbookByPath(serviceURL, runbookPath);
List <RunbookParameter> runbookParameters = GetRunbookParametersById(serviceURL,
runbook.Id);
Job job = StartRunbookJob(serviceURL, runbook.Id, runbookParameters, parameters);
Console.WriteLine("Successfully started runbook. Job ID: {0}", job.Id.ToString());
Console.ReadKey();
}
//public void PopulateWithDependencies(Runbook runbook, ConDepSettings settings)
//{
// if (!HasDependenciesDefined(runbook)) return;
// runbook.Dependencies = GetDependeciesForRunbook(runbook, settings);
//}
public List <Runbook> GetDependeciesForRunbook(Runbook runbook, ConDepSettings settings)
{
var typeName = typeof(IDependOn <>).Name;
var typeInterfaces = runbook.GetType().GetInterfaces();
var dependencies = typeInterfaces.Where(x => x.Name == typeName);
var dependencyInstances = new List <Runbook>();
foreach (var infraInterface in dependencies)
{
var dependencyType = infraInterface.GetGenericArguments().Single();
var dependencyInstance = settings.Options.Assembly.CreateInstance(dependencyType.FullName) as Runbook;
dependencyInstances.AddRange(new RunbookDependencyHandler().GetDependeciesForRunbook(dependencyInstance, settings));
dependencyInstances.Add(dependencyInstance);
}
return(dependencyInstances);
}
public void AddToRunbooks(Runbook runbook)
{
base.AddObject("Runbooks", runbook);
}
public static Runbook CreateRunbook(global::System.Guid tenantID, global::System.Guid runbookID, string runbookName, global::System.DateTime creationTime, global::System.DateTime lastModifiedTime, bool isApiOnly, bool isGlobal, bool logDebug, bool logVerbose, bool logProgress)
{
Runbook runbook = new Runbook();
runbook.TenantID = tenantID;
runbook.RunbookID = runbookID;
runbook.RunbookName = runbookName;
runbook.CreationTime = creationTime;
runbook.LastModifiedTime = lastModifiedTime;
runbook.IsApiOnly = isApiOnly;
runbook.IsGlobal = isGlobal;
runbook.LogDebug = logDebug;
runbook.LogVerbose = logVerbose;
runbook.LogProgress = logProgress;
return runbook;
}
public bool HasDependenciesDefined(Runbook artifact)
{
var typeName = typeof(IDependOn<>).Name;
var interfaces = artifact.GetType().GetInterfaces();
return interfaces.Any(x => x.Name == typeName);
}
public void DeleteRunbook(string automationAccountName, string runbookName)
{
Runbook runbook = this.GetRunbook(automationAccountName, runbookName);
this.DeleteRunbook(automationAccountName, runbook.Id);
}
/// <summary>
/// Returns a dictionary of parameter settings from the runbook where key is the parameter name and value is parameter setting model
/// </summary>
/// <param name="resourceGroup"></param>
/// <param name="automationAccount"></param>
/// <param name="runbookName"></param>
/// <returns></returns>
public async Task <Dictionary <string, RunbookParameterSetting> > GetRunbookParameterSettings(string resourceGroup, string automationAccount, string runbookName)
{
//Get runbook powershell content
string runbookContent = (await GetContentWithHttpMessagesAsync(resourceGroup, automationAccount, runbookName)).Body;
//Get runbook
Runbook runbook = await GetRunbook(resourceGroup, automationAccount, runbookName);
//Get sorted runbook parameters
IOrderedEnumerable <KeyValuePair <string, RunbookParameter> > runbookParameters = runbook.Parameters.OrderBy(o => o.Value.Position);
//Create empty dictionary
Dictionary <string, RunbookParameterSetting> runbookParameterSettings = new Dictionary <string, RunbookParameterSetting>();
int i = 0;
foreach (KeyValuePair <string, RunbookParameter> runbookVariable in runbookParameters)
{
RunbookParameterSetting runbookParameterSetting = new RunbookParameterSetting()
{
IsRequired = (bool)runbookVariable.Value.IsMandatory,
DefaultValue = runbookVariable.Value.DefaultValue
};
if (runbookParameterSetting.DefaultValue != null)
{
runbookParameterSetting.DefaultValue = runbookParameterSetting.DefaultValue.Replace("'", "");
}
;
string pattern;
if (i == 0)
{
//First parameter configs - get everything between 'Param(' and '<nameoffirstvariable>'
pattern = $@"(?s)(?<=Param\()(.*?)(?=\${runbookVariable.Key})";
}
else
{
//Subsequent parameter configs - get everything between '<nameofpreviousvariable>' and '<nameofcurrentvariable>'
pattern = $@"(?s)(?<={runbookParameters.ToList()[i - 1].Key})(.*?)(?=\${runbookVariable.Key})";
}
Regex regex = new Regex(pattern);
MatchCollection paramSettingsMatches = regex.Matches(runbookContent);
if (paramSettingsMatches != null && paramSettingsMatches.Count > 0)
{
var paramSettings = paramSettingsMatches[0];
//ValidateSet - Within the specific parameter config check for ValidateSet and add it to RunbookParameterSetting instance
regex = new Regex(Constants.RegexPatternValidateSet);
MatchCollection matchesValidateSet = regex.Matches(paramSettings.Value);
if (matchesValidateSet != null && matchesValidateSet.Count > 0)
{
runbookParameterSetting.ValidateSet = (matchesValidateSet[0].Value.Replace("\"", "").Replace("'", "")).Split(",");
}
//Alias - Within the specific parameter config check for Alias and add it to RunbookParameterSetting instance
regex = new Regex(Constants.RegexPatternAlias);
MatchCollection matchesAlias = regex.Matches(paramSettings.Value);
if (matchesAlias != null && matchesAlias.Count > 0)
{
runbookParameterSetting.DisplayName = matchesAlias[0].Value.Replace("\"", "").Replace("'", "");
}
}
//Add to dictionary
runbookParameterSettings.Add(runbookVariable.Key, runbookParameterSetting);
i++;
}
return(runbookParameterSettings);
}
public JobProperties()
{
Parameters = new Dictionary<string, object>();
Runbook = new Runbook();
}
private void CancelButton_Click(object sender, RoutedEventArgs e)
{
_selectedRunbook = null;
Close();
}
public SMARunbookModel(Runbook smaRunbook)
{
this.RunbookId = smaRunbook.RunbookId;
this.RunbookName = smaRunbook.RunbookName;
this.RunbookTag = smaRunbook.RunbookTag;
}
private void ChooseRunbook()
{
if (RunbooksListView.SelectedValue != null && RunbooksListView.SelectedValue is Runbook)
{
_selectedRunbook = ((Runbook)RunbooksListView.SelectedValue);
}
Close();
}
public static Runbook CreateRunbook(global::System.Guid ID, global::System.Guid folderId, string name, string createdBy, global::System.DateTime creationTime, string lastModifiedBy, global::System.DateTime lastModifiedTime, bool isMonitor, string path)
{
Runbook runbook = new Runbook();
runbook.Id = ID;
runbook.FolderId = folderId;
runbook.Name = name;
runbook.CreatedBy = createdBy;
runbook.CreationTime = creationTime;
runbook.LastModifiedBy = lastModifiedBy;
runbook.LastModifiedTime = lastModifiedTime;
runbook.IsMonitor = isMonitor;
runbook.Path = path;
return runbook;
}
