private IExecAction BuildAction(IScheduledResource resource)
{
return(ConvertorFactory.CreateExecAction(WarewolfAgentPath,
String.Format("\"Workflow:{0}\" \"TaskName:{1}\"",
resource.WorkflowName.Trim(),
resource.Name.Trim())));
}
public void Save(IScheduledResource resource, string userName, string password)
{
if (!_securityWrapper.IsWindowsAuthorised(Sebatchlogonright, userName))
{
throw new SecurityException(
@"This task requires that the user account specified has 'Log On As Batch' job rights.
Please contact your Windows System Administrator.");
}
if (!_securityWrapper.IsWarewolfAuthorised(Sebatchlogonright, userName, resource.ResourceId.ToString()))
{
throw new SecurityException(
String.Format(@"This Workflow requires that you have Execute permission on the '{0}' Workflow.
Please contact your Warewolf System Administrator.", resource.WorkflowName));
}
if (resource.Name.Any(a => "\\/:*?\"<>|".Contains(a)))
{
throw new Exception("The task name may not contain the following characters \\/:*?\"<>| .");
}
var folder = TaskService.GetFolder(WarewolfFolderPath);
var created = CreateNewTask(resource);
created.Settings.Enabled = resource.Status == SchedulerStatus.Enabled;
folder.RegisterTaskDefinition(resource.Name, created, TaskCreation.CreateOrUpdate, userName, password,
TaskLogonType.InteractiveTokenOrPassword);
}
void UpdateTrigger(IScheduledResource task, Table table)
{
var sched = table.Rows[0]["ScheduleType"];
Microsoft.Win32.TaskScheduler.Trigger x;
switch (sched)
{
case "At log on":
x = new LogonTrigger();
break;
case "On a schedule":
x = CreateScheduleTrigger(table);
break;
case "At Startup":
x = new BootTrigger();
break;
case "On Idle":
x = new IdleTrigger();
break;
default:
x = new DailyTrigger();
break;
}
task.Trigger.Trigger = new Dev2Trigger(new TaskServiceConvertorFactory(), x);
}
public IList <IResourceHistory> CreateHistory(IScheduledResource resource)
{
// group event log entries by correlation id
ITaskEventLog evt = _factory.CreateTaskEventLog(String.Format("\\{0}\\", _warewolfFolderPath) + resource.Name);
var groupings =
from a in
evt.Where(x => !String.IsNullOrEmpty(x.Correlation) && !String.IsNullOrEmpty(x.TaskCategory) && _taskStates.Values.Contains(x.TaskCategory))
group a by a.Correlation
into corrGroup
select new
{
StartDate = corrGroup.Min(a => a.TimeCreated),
EndDate = corrGroup.Max(a => a.TimeCreated),
EventId = corrGroup.Max(a => a.EventId),
corrGroup.Key
};
// for each grouping get the data and debug output
IList <IResourceHistory> eventList = groupings.OrderBy(a => a.StartDate).Reverse().Take(resource.NumberOfHistoryToKeep == 0 ? int.MaxValue : resource.NumberOfHistoryToKeep).Select(
a =>
new ResourceHistory("", CreateDebugHistory(DebugHistoryPath, a.Key),
new EventInfo(a.StartDate.Value, a.StartDate.HasValue && a.EndDate.HasValue ? a.EndDate.Value.Subtract(a.StartDate.Value) : TimeSpan.MaxValue, a.EndDate.Value, GetRunStatus(a.EventId, DebugHistoryPath, a.Key), a.Key, a.EventId < 103 ? "" : _taskStates[a.EventId]), GetUserName(DebugHistoryPath, a.Key))
as IResourceHistory).ToList();
return(eventList);
}
public void DeleteSchedule(IScheduledResource resource)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "DeleteScheduledResourceService" };
controller.AddPayloadArgument("Resource", builder);
controller.ExecuteCommand<string>(_model.Connection, _model.Connection.WorkspaceID);
}
public void DeleteSchedule(IScheduledResource resource)
{
ITaskFolder folder = TaskService.GetFolder(WarewolfFolderPath);
if (folder.TaskExists(resource.Name))
{
folder.DeleteTask(resource.Name, false);
}
}
protected override void GetCredentials(IScheduledResource scheduledResource)
{
if (string.IsNullOrEmpty(scheduledResource.UserName) || string.IsNullOrEmpty(scheduledResource.Password))
{
GetCredentialsCalled = true;
scheduledResource.UserName = "******";
scheduledResource.Password = "******";
}
}
public void ScheduledResourceModel_CorrectSelectedResources()
{
SetupSingleTask();
var model = new ScheduledResourceModel(_mockService.Object, _folderId, _agentPath, _convertorFactory.Object,
@"c:\", _wrapper.Object);
IScheduledResource a = model.ScheduledResources.First();
Assert.AreEqual("bob", a.Name);
Assert.AreEqual("a", a.WorkflowName);
}
public void DeleteSchedule(IScheduledResource resource)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController {
ServiceName = "DeleteScheduledResourceService"
};
controller.AddPayloadArgument("Resource", builder);
controller.ExecuteCommand <string>(_model.Connection, _model.Connection.WorkspaceID);
}
public IList <IResourceHistory> CreateHistory(IScheduledResource resource)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController {
ServiceName = "GetScheduledResourceHistoryService"
};
controller.AddPayloadArgument("Resource", builder);
return(controller.ExecuteCommand <IList <IResourceHistory> >(_model.Connection, _model.Connection.WorkspaceID));
}
public void Save(IScheduledResource resource, string userName, string password)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "SaveScheduledResourceService" };
controller.AddPayloadArgument("Resource", builder);
controller.AddPayloadArgument("UserName", userName);
controller.AddPayloadArgument("Password", password);
controller.ExecuteCommand<string>(_model.Connection, _model.Connection.WorkspaceID);
resource.IsDirty = false;
}
public void Save(IScheduledResource resource, string userName, string password)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController {
ServiceName = "SaveScheduledResourceService"
};
controller.AddPayloadArgument("Resource", builder);
controller.AddPayloadArgument("UserName", userName);
controller.AddPayloadArgument("Password", password);
controller.ExecuteCommand <string>(_model.Connection, _model.Connection.WorkspaceID);
}
public bool Save(IScheduledResource resource, out string errorMessage)
{
try
{
Save(resource, resource.UserName, resource.Password);
}
catch (Exception e)
{
errorMessage = e.Message;
return(false);
}
errorMessage = "";
return(true);
}
public virtual void GetCredentials(IScheduledResource scheduledResource)
{
var cancelled = false;
while ((String.IsNullOrEmpty(AccountName) || String.IsNullOrEmpty(Password)) && !cancelled)
{
CredentialsDialog credentialsDialog = new CredentialsDialog {
UserName = scheduledResource.UserName, Options = CredentialsDialogOptions.GenericCredentials, ValidatePassword = true
};
var dialogResult = credentialsDialog.ShowDialog();
if (dialogResult == System.Windows.Forms.DialogResult.Cancel)
{
cancelled = true;
}
AccountName = credentialsDialog.UserName;
Password = credentialsDialog.Password;
}
}
private IDev2TaskDefinition CreateNewTask(IScheduledResource resource)
{
IDev2TaskDefinition created = TaskService.NewTask();
created.Data = string.Format("{0}~{1}", resource.Name, resource.NumberOfHistoryToKeep);
var trigger = _factory.SanitiseTrigger(resource.Trigger.Trigger);
created.AddTrigger(trigger);
created.AddAction(BuildAction(resource));
created.Settings.StartWhenAvailable = resource.RunAsapIfScheduleMissed;
created.Settings.MultipleInstances = resource.AllowMultipleIstances
? TaskInstancesPolicy.Parallel
: TaskInstancesPolicy.Queue;
created.Settings.Hidden = true;
return(created);
}
public IList <IResourceHistory> CreateHistory(IScheduledResource resource)
{
var evt = _factory.CreateTaskEventLog($"\\{_warewolfFolderPath}\\" + resource.Name);
var groupings = from a in evt.Where(x => !string.IsNullOrEmpty(x.Correlation) &&
!string.IsNullOrEmpty(x.TaskCategory) && _taskStates.Values.Contains(x.TaskCategory))
group a by a.Correlation into corrGroup
select new
{
StartDate = corrGroup.Min(a => a.TimeCreated),
EndDate = corrGroup.Max(a => a.TimeCreated),
EventId = corrGroup.Max(a => a.EventId),
corrGroup.Key
};
// for each grouping get the data and debug output
IList <IResourceHistory> eventList = groupings.OrderBy(a => a.StartDate).Reverse()
.Take(resource.NumberOfHistoryToKeep == 0 ? int.MaxValue : resource.NumberOfHistoryToKeep)
.Select(a =>
{
TimeSpan duration;
DateTime start;
DateTime end;
var debugOutput = CreateDebugHistory(DebugHistoryPath, a.Key);
var output = debugOutput.FirstOrDefault();
if (output != null)
{
duration = new TimeSpan(output.Duration.Hours, output.Duration.Minutes, output.Duration.Seconds);
start = output.StartTime;
end = output.EndTime;
}
else
{
start = a.StartDate.Value;
end = a.EndDate.Value;
duration = a.StartDate.HasValue && a.EndDate.HasValue ? a.EndDate.Value.Subtract(a.StartDate.Value) : TimeSpan.MaxValue;
}
return(new ResourceHistory("", debugOutput,
new EventInfo(start, duration, end, GetRunStatus(a.EventId, DebugHistoryPath, a.Key), a.Key, a.EventId < 103 ? "" : _taskStates[a.EventId]), GetUserName(DebugHistoryPath, a.Key))
as IResourceHistory);
}).ToList();
var result = eventList.Where(history => history.TaskHistoryOutput.Success != ScheduleRunStatus.Unknown).ToList();
return(result);
}
IDev2TaskDefinition CreateNewTask(IScheduledResource resource)
{
var created = TaskService.NewTask();
created.Data = $"{resource.Name}~{resource.NumberOfHistoryToKeep}";
var trigger = _factory.SanitiseTrigger(resource.Trigger.Trigger);
created.AddTrigger(trigger);
created.AddAction(BuildAction(resource));
created.Settings.StartWhenAvailable = resource.RunAsapIfScheduleMissed;
created.Settings.MultipleInstances = resource.AllowMultipleIstances ? TaskInstancesPolicy.Parallel : TaskInstancesPolicy.Queue;
created.Settings.Hidden = true;
if (created.Instance?.Principal != null)
{
created.Instance.Principal.RunLevel = TaskRunLevel.Highest;
}
return(created);
}
public bool Save(IScheduledResource resource, out string errorMessage)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "SaveScheduledResourceService" };
controller.AddPayloadArgument("Resource", builder);
controller.AddPayloadArgument("PreviousResource", resource.OldName);
controller.AddPayloadArgument("UserName", resource.UserName);
controller.AddPayloadArgument("Password", resource.Password);
var executeCommand = controller.ExecuteCommand<ExecuteMessage>(_model.Connection, _model.Connection.WorkspaceID);
errorMessage = "";
if(executeCommand != null)
{
resource.IsDirty = executeCommand.HasError;
errorMessage = executeCommand.Message.ToString();
return !executeCommand.HasError;
}
return true;
}
protected virtual void GetCredentials(IScheduledResource scheduledResource)
{
var cancelled = false;
while ((String.IsNullOrEmpty(_schedulerViewModel.AccountName) || String.IsNullOrEmpty(_schedulerViewModel.Password)) && !cancelled)
{
NetworkCredential cred;
CredentialUI.GetCredentialsVistaAndUp(scheduledResource.Name, out cred);
if (cred == null)
{
cancelled = true;
}
else
{
_schedulerViewModel.AccountName = cred.UserName;
_schedulerViewModel.Password = cred.Password;
}
}
}
public void Save(IScheduledResource resource, string userName, string password)
{
if (!_securityWrapper.IsWindowsAuthorised(Sebatchlogonright, userName))
{
throw new SecurityException(Warewolf.Studio.Resources.Languages.Core.SchedulerLogOnAsBatchError);
}
if (!_securityWrapper.IsWarewolfAuthorised(Sebatchlogonright, userName, resource.ResourceId.ToString()))
{
throw new SecurityException(String.Format(Warewolf.Studio.Resources.Languages.Core.SchedulerExecutePermissionError, resource.WorkflowName));
}
if (resource.Name.Any(a => "\\/:*?\"<>|".Contains(a)))
{
throw new Exception(Warewolf.Studio.Resources.Languages.Core.SchedulerInvalidCharactersError + " \\/:*?\"<>| .");
}
var folder = TaskService.GetFolder(WarewolfFolderPath);
var created = CreateNewTask(resource);
created.Settings.Enabled = resource.Status == SchedulerStatus.Enabled;
folder.RegisterTaskDefinition(resource.Name, created, TaskCreation.CreateOrUpdate, userName, password, TaskLogonType.InteractiveTokenOrPassword);
}
public bool Save(IScheduledResource resource, out string errorMessage)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController {
ServiceName = "SaveScheduledResourceService"
};
controller.AddPayloadArgument("Resource", builder);
controller.AddPayloadArgument("PreviousResource", resource.OldName);
controller.AddPayloadArgument("UserName", resource.UserName);
controller.AddPayloadArgument("Password", resource.Password);
var executeCommand = controller.ExecuteCommand <ExecuteMessage>(_model.Connection, _model.Connection.WorkspaceID);
errorMessage = "";
if (executeCommand != null)
{
errorMessage = executeCommand.Message.ToString();
return(!executeCommand.HasError);
}
return(true);
}
public bool Equals(IScheduledResource other)
{
if (other == null)
{
return(false);
}
if (IsNew)
{
return(false);
}
var nameEqual = other.Name.Equals(Name, StringComparison.CurrentCultureIgnoreCase);
var statusEqual = other.Status == Status;
var nextRunDateEqual = other.NextRunDate == NextRunDate;
var triggerEqual = TriggerEqual(other.Trigger, Trigger);
var numberOfHistoryToKeepEqual = other.NumberOfHistoryToKeep == NumberOfHistoryToKeep;
var workflowNameEqual = other.WorkflowName.Equals(WorkflowName, StringComparison.InvariantCultureIgnoreCase);
var runAsapIfMissedEqual = other.RunAsapIfScheduleMissed == RunAsapIfScheduleMissed;
var allowMultipleInstancesEqual = other.AllowMultipleIstances == AllowMultipleIstances;
var userNameEqual = !string.IsNullOrEmpty(other.UserName) && !string.IsNullOrEmpty(UserName) ? other.UserName.Equals(UserName, StringComparison.InvariantCultureIgnoreCase) : string.IsNullOrEmpty(other.UserName) && string.IsNullOrEmpty(UserName);
return(nameEqual && statusEqual && nextRunDateEqual && triggerEqual && numberOfHistoryToKeepEqual && workflowNameEqual &&
runAsapIfMissedEqual && allowMultipleInstancesEqual && userNameEqual);
}
public IList<IResourceHistory> CreateHistory(IScheduledResource resource)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "GetScheduledResourceHistoryService" };
controller.AddPayloadArgument("Resource", builder);
return controller.ExecuteCommand<IList<IResourceHistory>>(_model.Connection, _model.Connection.WorkspaceID);
}
void UpdateTrigger(IScheduledResource task, Table table)
{
var sched = table.Rows[0]["ScheduleType"];
Trigger x;
switch(sched)
{
case "At log on":
x = new LogonTrigger();
break;
case "On a schedule":
x = CreateScheduleTrigger(table);
break;
case "At Startup":
x = new BootTrigger();
break;
case "On Idle":
x = new IdleTrigger();
break;
default:
x = new DailyTrigger();
break;
}
task.Trigger.Trigger = new Dev2Trigger(new TaskServiceConvertorFactory(), x);
}
public bool Equals(IScheduledResource other)
{
return(!IsDirty);
}
public void DeleteSchedule(IScheduledResource resource)
{
ITaskFolder folder = TaskService.GetFolder(WarewolfFolderPath);
if(folder.TaskExists(resource.Name))
folder.DeleteTask(resource.Name, false);
}
public void Save(IScheduledResource resource, string userName, string password)
{
if(!_securityWrapper.IsWindowsAuthorised(Sebatchlogonright, userName))
{
throw new SecurityException(
@"This task requires that the user account specified has 'Log On As Batch' job rights.
Please contact your Windows System Administrator.");
}
if(!_securityWrapper.IsWarewolfAuthorised(Sebatchlogonright, userName, resource.ResourceId.ToString()))
{
throw new SecurityException(
String.Format(@"This Workflow requires that you have Execute permission on the '{0}' Workflow.
Please contact your Warewolf System Administrator.", resource.WorkflowName));
}
if(resource.Name.Any(a => "\\/:*?\"<>|".Contains(a)))
throw new Exception("The task name may not contain the following characters \\/:*?\"<>| .");
var folder = TaskService.GetFolder(WarewolfFolderPath);
var created = CreateNewTask(resource);
created.Settings.Enabled = resource.Status == SchedulerStatus.Enabled;
folder.RegisterTaskDefinition(resource.Name, created, TaskCreation.CreateOrUpdate, userName, password,
TaskLogonType.InteractiveTokenOrPassword);
}
private IExecAction BuildAction(IScheduledResource resource)
{
return ConvertorFactory.CreateExecAction(WarewolfAgentPath,
String.Format("\"Workflow:{0}\" \"TaskName:{1}\"",
resource.WorkflowName.Trim(),
resource.Name.Trim()));
}
public IList<IResourceHistory> CreateHistory(IScheduledResource resource)
{
// group event log entries by correlation id
ITaskEventLog evt = _factory.CreateTaskEventLog(String.Format("\\{0}\\", _warewolfFolderPath) + resource.Name);
var groupings =
from a in
evt.Where(x => !String.IsNullOrEmpty(x.Correlation) && !String.IsNullOrEmpty(x.TaskCategory) && _taskStates.Values.Contains(x.TaskCategory))
group a by a.Correlation
into corrGroup
select new
{
StartDate = corrGroup.Min(a => a.TimeCreated),
EndDate = corrGroup.Max(a => a.TimeCreated),
EventId = corrGroup.Max(a => a.EventId),
corrGroup.Key
};
// for each grouping get the data and debug output
IList<IResourceHistory> eventList = groupings.OrderBy(a => a.StartDate).Reverse().Take(resource.NumberOfHistoryToKeep == 0 ? int.MaxValue : resource.NumberOfHistoryToKeep).Select(
a =>
new ResourceHistory("", CreateDebugHistory(DebugHistoryPath, a.Key),
new EventInfo(a.StartDate.Value, a.StartDate.HasValue && a.EndDate.HasValue ? a.EndDate.Value.Subtract(a.StartDate.Value) : TimeSpan.MaxValue, a.EndDate.Value, GetRunStatus(a.EventId, DebugHistoryPath, a.Key), a.Key, a.EventId < 103 ? "" : _taskStates[a.EventId]), GetUserName(DebugHistoryPath, a.Key))
as IResourceHistory).ToList();
return eventList;
}
private IDev2TaskDefinition CreateNewTask(IScheduledResource resource)
{
IDev2TaskDefinition created = TaskService.NewTask();
created.Data = string.Format("{0}~{1}", resource.Name, resource.NumberOfHistoryToKeep);
var trigger = _factory.SanitiseTrigger(resource.Trigger.Trigger);
created.AddTrigger(trigger);
created.AddAction(BuildAction(resource));
created.Settings.StartWhenAvailable = resource.RunAsapIfScheduleMissed;
created.Settings.MultipleInstances = resource.AllowMultipleIstances
? TaskInstancesPolicy.Parallel
: TaskInstancesPolicy.Queue;
created.Settings.Hidden = true;
return created;
}
public override void GetCredentials(IScheduledResource scheduledResource)
{
if(string.IsNullOrEmpty(scheduledResource.UserName) || string.IsNullOrEmpty(scheduledResource.Password))
{
GetCredentialsCalled = true;
scheduledResource.UserName = "******";
scheduledResource.Password = "******";
}
}
IExecAction BuildAction(IScheduledResource resource) => ConvertorFactory.CreateExecAction(WarewolfAgentPath,
$"\"Workflow:{resource.WorkflowName.Trim()}\" \"TaskName:{resource.Name.Trim()}\" \"ResourceId:{resource.ResourceId}\"");
public bool Save(IScheduledResource resource, out string errorMessage)
{
try
{
Save(resource, resource.UserName, resource.Password);
}
catch(Exception e)
{
errorMessage = e.Message;
return false;
}
errorMessage = "";
return true;
}
public void SetItem(IScheduledResource item)
{
}
public bool Equals(IScheduledResource other) => false;
public virtual void GetCredentials(IScheduledResource scheduledResource)
{
var cancelled = false;
while((String.IsNullOrEmpty(AccountName) || String.IsNullOrEmpty(Password)) && !cancelled)
{
CredentialsDialog credentialsDialog = new CredentialsDialog { UserName = scheduledResource.UserName, Options = CredentialsDialogOptions.GenericCredentials, ValidatePassword = true };
var dialogResult = credentialsDialog.ShowDialog();
if(dialogResult == System.Windows.Forms.DialogResult.Cancel)
{
cancelled = true;
}
AccountName = credentialsDialog.UserName;
Password = credentialsDialog.Password;
}
}
public bool Equals(IScheduledResource other)
{
return(false);
}
