public IResult SoftDelete(TaskConfiguration instance, string user)
{
try
{
using (var ctx = new PureDataContext(_pureDataConnectionString))
{
var archive = new TaskConfigurationsArchived
{
TaskConfigurationId = instance.TaskConfigurationId,
DeletedBy = user,
IsDeleted = true,
DeletedOn = DateTime.Now
};
ctx.Set <TaskConfigurationsArchived>().Add(archive);
instance.TaskConfigurationsArchived = archive;
ctx.SaveChanges();
}
return(new ResultFactory().Ok());
}
catch (Exception ex)
{
return(new ResultFactory().Error(ex));
}
}
//---------------------------------------------------------------------------------------------------------------------
/// <summary>Inserts the scheduler and its parameters into the database.</summary>
public override void Store()
{
bool existedBefore = Exists;
if (Identifier == null)
{
Identifier = Guid.NewGuid().ToString();
}
if (Name == null)
{
Name = Identifier;
}
HasTaskConfiguration = (taskConfiguration != null);
base.Store();
if (RunConfiguration != null)
{
RunConfiguration.Store();
}
if (HasTaskConfiguration)
{
TaskConfiguration.Store();
}
//if (existedBefore) context.Execute(String.Format("DELETE FROM schedulerparam WHERE id_scheduler={0};", Id));
CreateParameters();
}
public static void GoToRpSignIn(IWebDriver driver, TaskConfiguration config)
{
string url = $"https://{config.Farm.FarmName}/adfs/ls/?wa=wsignin1.0&wtrealm={config.RelyingPartyData.Wtrealm}&wreply={config.RelyingPartyData.Wreply}";
driver.Navigate().GoToUrl(url);
LogAndScreenshot(driver, config);
}
public void Dummy_depends_on_Clean()
{
var sut = new TaskConfiguration(typeof(MyWrapperClass.Dummy));
var deps = sut.GetDependencies(Setup.FakeScriptParamsObject());
deps[0].Should().Be <MyWrapperClass.Clean>();
}
public static void Main()
{
var webJobsDashboard = CloudConfigurationManager.GetSetting("AzureWebJobsDashboard");
var webJobsStorage = CloudConfigurationManager.GetSetting("AzureWebJobsStorage");
var storageAcc = CloudConfigurationManager.GetSetting("StorageAccount");
if (string.IsNullOrWhiteSpace(webJobsStorage) || string.IsNullOrWhiteSpace(storageAcc) || string.IsNullOrWhiteSpace(webJobsDashboard))
{
Console.WriteLine("Please add the Azure Storage account credentials ['StorageAccount' & 'AzureWebJobsStorage' & 'AzureWebJobsDashboard'] in App.config");
Console.Read();
return;
}
else
{
var config = new TaskConfiguration()
{
ConnectionString = storageAcc,
StorageElements = new StorageElements(),
};
var factory = new ImageTaskFactory();
foreach (var task in factory.Initialize(config))
{
task.Start();
}
var host = new JobHost();
host.RunAndBlock();
}
}
public override TaskConnections GetConnections(TaskConfiguration config) {
var viewModel = (EncodeViewModel)config.Settings;
return new TaskConnections(
new[] { new TaskInput(0, true, new[] { "VideoAsset" }) }, // Expects one video input asset.
new[] { new TaskOutput(0, "VideoAsset", viewModel.SelectedEncodingPreset ) } // Produces one video output asset.
);
}
public async Task BuildAsync_ShouldBuildStaticTasks()
{
// arrange
var sut = new CsissorsBuilder()
.AddMockRepository()
.AddTaskContainer <MockContainer>();
var expectedConfiguration = new TaskConfiguration(
new IntervalSchedule(TimeSpan.FromDays(1), false),
FailureMode.None,
ExecutionMode.AtLeastOnce,
TimeSpan.FromSeconds(60),
new Dictionary <string, object?>()
);
// act
var context = await sut.BuildAsync(CancellationToken.None);
// assert
context.Tasks.StaticTasks.Should().HaveCount(1);
var task = context.Tasks.StaticTasks[0];
task.Name.Should().Be("Bar");
task.Configuration.Should().BeEquivalentTo(expectedConfiguration,
(config) => config.RespectingRuntimeTypes());
}
public async Task BuildAsync_ShouldBuildStaticTasks_Delegate()
{
// arrange
var expectedConfiguration = new TaskConfiguration(
new IntervalSchedule(TimeSpan.FromDays(1), false),
FailureMode.None,
ExecutionMode.AtLeastOnce,
TimeSpan.FromSeconds(60),
new Dictionary <string, object?>()
);
var sut = new CsissorsBuilder()
.AddMockRepository()
.AddTask("mock", expectedConfiguration, async() => throw new IOException());
// act
var context = await sut.BuildAsync(CancellationToken.None);
// assert
context.Tasks.StaticTasks.Should().HaveCount(1);
var task = context.Tasks.StaticTasks[0];
task.Name.Should().Be("mock");
task.Configuration.Should().BeSameAs(expectedConfiguration);
await Assert.ThrowsAsync <IOException>(() => task.ExecuteAsync(Mock.Of <ITaskContext>()));
}
public TaskExecutionContext(ITasklingConfiguration configuration,
ITaskExecutionRepository taskExecutionRepository,
ICriticalSectionRepository criticalSectionRepository,
IBlockFactory blockFactory,
IRangeBlockRepository rangeBlockRepository,
IListBlockRepository listBlockRepository,
IObjectBlockRepository objectBlockRepository,
ICleanUpService cleanUpService,
string applicationName,
string taskName,
TaskExecutionOptions taskExecutionOptions)
{
_configuration = configuration;
_taskExecutionRepository = taskExecutionRepository;
_criticalSectionRepository = criticalSectionRepository;
_blockFactory = blockFactory;
_rangeBlockRepository = rangeBlockRepository;
_listBlockRepository = listBlockRepository;
_objectBlockRepository = objectBlockRepository;
_cleanUpService = cleanUpService;
_taskExecutionInstance = new TaskExecutionInstance();
_taskExecutionInstance.ApplicationName = applicationName;
_taskExecutionInstance.TaskName = taskName;
_taskExecutionOptions = taskExecutionOptions;
_executionHasFailed = false;
_taskConfiguration = _configuration.GetTaskConfiguration(applicationName, taskName);
}
public void Save(TaskConfiguration instance)
{
using (var ctx = new PureDataContext(_pureDataConnectionString))
{
if (
ctx.Set <TaskConfiguration>().Any(
c => c.TaskConfigurationId == instance.TaskConfigurationId))
{
ctx.Set <TaskConfiguration>().Attach(instance);
ctx.Entry(instance).State = EntityState.Modified;
ctx.SaveChanges();
}
else
{
var taskConfig = new TaskConfiguration
{
Body = instance.Body,
Title = instance.Title,
LeadTimeDays = instance.LeadTimeDays,
Sequence = instance.Sequence,
CaseStateId = instance.CaseStateId,
IsManual = instance.IsManual
};
ctx.Set <TaskConfiguration>().Add(taskConfig);
ctx.SaveChanges();
}
}
}
public void InitializeStorageTask()
{
var elements = Substitute.For <IStorageElements>();
elements.Container.Returns(Guid.NewGuid().ToString());
elements.Table.Returns(Guid.NewGuid().ToString());
elements.Queue.Returns(Guid.NewGuid().ToString());
var config = new TaskConfiguration
{
StorageElements = elements,
Versions = Substitute.For <IVersions>(),
ConnectionString = connectionString,
};
var factory = new ImageTaskFactory();
var tasks = factory.Tasks(config);
Assert.IsNotNull(tasks);
var inits = from t in tasks
where t.GetType() == typeof(InitializeStorageTask)
select t;
Assert.IsNotNull(inits);
Assert.AreEqual(4, inits.Count());
}
public void Pack_depends_on_Build_and_Dummy()
{
var sut = new TaskConfiguration(typeof(MyWrapperClass.Pack));
var deps = sut.GetDependencies(Setup.FakeScriptParamsObject());
deps[0].Should().Be <MyWrapperClass.Build>();
deps[1].Should().Be <MyWrapperClass.Dummy>();
}
//---------------------------------------------------------------------------------------------------------------------
public override void Load()
{
base.Load();
if (HasTaskConfiguration)
{
TaskConfiguration.Load();
}
}
public static TaskConfiguration <MaintenanceWorkItem> IncludeElmah(this TaskConfiguration <MaintenanceWorkItem> task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
return(task.Step <CleanUpElmahErrorsStep>());
}
public static TaskConfiguration <MaintenanceWorkItem> IncludeMongoDb(this TaskConfiguration <MaintenanceWorkItem> task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
return(task.Step <LogRotatorStep>());
}
public override TaskConnections GetConnections(TaskConfiguration config)
{
var viewModel = (EncodeViewModel)config.Settings;
return(new TaskConnections(
new[] { new TaskInput(0, true, new[] { "VideoAsset" }) }, // Expects one video input asset.
new[] { new TaskOutput(0, "VideoAsset", viewModel.SelectedEncodingPreset) } // Produces one video output asset.
));
}
public static TaskConfiguration <MonitorWorkItem> IncludeMongoDb(this TaskConfiguration <MonitorWorkItem> task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
return(task.Step <PingMongoDbStep>());
}
public static TaskConfiguration <MonitorWorkItem> IncludeElmah(this TaskConfiguration <MonitorWorkItem> task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
return(task.Step <ExportElmahErrorsStep>());
}
public void SetsColorBasedOnComplete(string line)
{
var config = new TaskConfiguration();
var task = new TaskItem(line);
var result = task.ToColorString(false, config);
result.Should().HaveCount(3);
result[0].Color.Should().Be(ConsoleColor.DarkGray);
result[0].BackgroundColor.Should().BeNull();
}
public void SetsTheCompletionDateColor()
{
var config = new TaskConfiguration();
var task = new TaskItem("x 2020-10-22 2020-10-15 Complete");
var result = task.ToColorString(false, config);
result.Should().HaveCount(4);
result[1].Color.Should().Be(ConsoleColor.Magenta);
result[1].BackgroundColor.Should().BeNull();
}
public void TokenizesMeta(string line, int pos)
{
var config = new TaskConfiguration();
var task = new TaskItem(line);
var result = task.ToColorString(false, config);
result.Should().HaveCount(3);
result[pos].Color.Should().Be(ConsoleColor.DarkCyan);
result[pos].BackgroundColor.Should().BeNull();
}
public void SetsColorBasedOnPriorityAndComplete(string line, ConsoleColor?expected)
{
var config = new TaskConfiguration();
var task = new TaskItem(line);
var result = task.ToColorString(false, config);
result.Should().HaveCount(2);
result[0].Color.Should().Be(expected);
result[0].BackgroundColor.Should().BeNull();
}
public void Build_shouldnt_execute_when_condition()
{
var sut = new TaskConfiguration(typeof(MyWrapperClass.Build));
var build = new MyWrapperClass.Build(sut);
var init = Setup.FakeScriptParamsObject();
sut.ShouldExecute(init).Should().BeTrue();
init.ScriptParams[0] = "skip";
sut.ShouldExecute(init).Should().BeFalse();
}
private async Task RegisterBackgroundTask()
{
var task = await TaskConfiguration.RegisterBackgroundTask(
typeof(LiveTileTask),
"LiveTile",
new TimeTrigger(60 * 12, false),
new SystemCondition(SystemConditionType.InternetAvailable));
task.Completed += Task_Completed;
}
public void Constructor()
{
var config = new TaskConfiguration()
{
Versions = new Versions(),
StorageElements = new StorageElements(),
};
new ImageDequeueSetup(config);
}
public CacheServerConfigSetting()
{
log = new Alachisoft.NCache.Config.Dom.Log();
perfCounters = new Alachisoft.NCache.Config.Dom.PerfCounters();
cleanup = new Alachisoft.NCache.Config.Dom.Cleanup();
notifications = new Alachisoft.NCache.Config.Dom.Notifications();
_taskConfiguration = new TaskConfiguration();
deathDetection = new ClientDeathDetection();
clientActivityNotification = new ClientActivityNotification();
expirationPolicy = new Alachisoft.NCache.Config.Dom.ExpirationPolicy();
}
public void CanOverrideBackgroundColor()
{
var config = new TaskConfiguration();
config.Priorities['A'].BackgroundColor = ConsoleColor.DarkRed;
var task = new TaskItem("(A) Yellow");
var result = task.ToColorString(false, config);
result.Should().HaveCount(2);
result[0].Color.Should().Be(ConsoleColor.Yellow);
result[0].BackgroundColor.Should().Be(ConsoleColor.DarkRed);
}
public void IfDateColorIsNullUsesPriorityColor()
{
var config = new TaskConfiguration();
config.DateColor = null;
var task = new TaskItem("(A) 2020-10-15 Todo");
var result = task.ToColorString(false, config);
result.Should().HaveCount(3);
result[1].Color.Should().Be(ConsoleColor.Yellow);
result[1].BackgroundColor.Should().BeNull();
}
public static TaskConfiguration <MaintenanceWorkItem> IncludeUCommerce(this TaskConfiguration <MaintenanceWorkItem> task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
task.Application.UseUCommerce();
return(task
.Step <UCommerceIndexMaintenanceStep>());
}
public int CountNecroMatches(int kfiId, TaskConfiguration configuration, DateTime dueDate)
{
using (var ctx = new PureDataContext(_pureDataConnectionString))
{
return(ctx.Set <Task>().Count(
x => x.KfiId == kfiId &&
x.TaskConfigurationId == configuration.TaskConfigurationId &&
x.DueDate == dueDate &&
x.Title == configuration.Title &&
x.Body == configuration.Body));
}
}
public void IfDateColorIsNullUsesDoneColor()
{
var config = new TaskConfiguration();
config.DateColor = null;
var task = new TaskItem("x 2020-10-22 2020-10-15 Complete");
var result = task.ToColorString(false, config);
result.Should().HaveCount(4);
result[1].Color.Should().Be(ConsoleColor.DarkGray);
result[1].BackgroundColor.Should().BeNull();
}
public override ITask CreateTask(TaskConfiguration config, TaskCollection tasks, IEnumerable<IAsset> inputAssets) {
var viewModel = (EncodeViewModel)config.Settings;
var task = tasks.AddNew(
viewModel.SelectedEncodingPreset,
_wamsClient.GetLatestMediaProcessorByName(MediaProcessorName.WindowsAzureMediaEncoder),
viewModel.SelectedEncodingPreset,
TaskOptions.None);
task.InputAssets.AddRange(inputAssets);
task.OutputAssets.AddNew(Guid.NewGuid().ToString(), AssetCreationOptions.None);
Logger.Information("New Encode task '{0}' was created.", task.Name);
return task;
}
public override ITask CreateTask(TaskConfiguration config, TaskCollection tasks, IEnumerable<IAsset> inputAssets) {
var settings = _orchardServices.WorkContext.CurrentSite.As<CloudMediaSettingsPart>();
var viewModel = (EncodeViewModel)config.Settings;
var encodingPreset = settings.WamsEncodingPresets.Where(x => x.Name == viewModel.SelectedEncodingPreset).Single();
var task = tasks.AddNew(
viewModel.SelectedEncodingPreset,
_wamsClient.GetLatestMediaProcessorByName(MediaProcessorName.WindowsAzureMediaEncoder),
!String.IsNullOrEmpty(encodingPreset.CustomXml) ? encodingPreset.CustomXml : encodingPreset.Name,
TaskOptions.None);
task.InputAssets.AddRange(inputAssets);
task.OutputAssets.AddNew(Guid.NewGuid().ToString(), AssetCreationOptions.None);
Logger.Information("New Encode task '{0}' was created.", task.Name);
return task;
}
public override string GetDisplayText(TaskConfiguration config) {
var viewModel = (EncodeViewModel)config.Settings;
return viewModel.SelectedEncodingPreset;
}
