private void CalcGroups(List <WorkLogDataRow> fileData, ObservableCollection <TaskGroup> groups, TaskGroup summary, DateTime dateFrom, DateTime dateTo, ModelSettings settings)
{
foreach (WorkLogDataRow row in fileData)
{
if (row.Key == null)
{
continue;
}
DateTime bookDate = GetDate(row.WorkDateStr, settings.SourceFileSettings.DateField);
if (bookDate >= dateFrom && bookDate <= dateTo)
{
TaskGroup group = groups.FirstOrDefault(x => x.Id == row.UserName);
if (group == null)
{
group = new TaskGroup();
group.Id = row.UserName;
group.Title = row.UserName;
groups.Add(group);
}
Task task = CreateTask(row, settings);
AddTaskToGroup(group, task);
AddTaskToGroup(summary, task);
}
}
}
public TaskGroupViewModel GetTaskGroup(string userId, int taskGroupId)
{
TaskGroup taskGroup = _context.TaskGroups
.Include(tg => tg.Course)
.Include(tg => tg.Variants)
.FirstOrDefault(tg => tg.Id == taskGroupId);
if (taskGroup == null)
{
throw new NotFoundException();
}
return(new TaskGroupViewModel
{
Id = taskGroupId,
CourseId = taskGroup.CourseId,
CourseName = taskGroup.Course.Name,
Name = taskGroup.Name,
Description = taskGroup.Description,
IsCourseTeacher = KaCakeUtils.IsCourseTeacher(_context, taskGroup.CourseId, userId),
Variants = taskGroup.Variants.Select(variant => new TaskVariantViewModel()
{
Id = variant.Id,
Name = variant.Name,
Description = variant.Description
}).ToList()
});
}
public ObservableCollection <TaskGroup> LoadTimeSheetReport(string fileName, DateTime dateFrom, DateTime dateTo, ModelSettings settings)
{
if (!File.Exists(fileName))
{
return(null);
}
List <WorkLogDataRow> fileData = ReadFile(fileName, settings);
if (fileData == null)
{
return(null);
}
ObservableCollection <TaskGroup> groups = new ObservableCollection <TaskGroup>();
TaskGroup summary = new TaskGroup {
IsSummary = true, Title = "All"
};
groups.Add(summary);
CalcGroups(fileData, groups, summary, dateFrom, dateTo, settings);
CalcTotals(groups, settings);
return(groups);
}
public async Task <int> CreateAsync(string name)
{
var group = new TaskGroup(name);
var id = await _taskGroupRepository.AddAsync(group);
return(id);
}
public TaskGroup UpdateTaskGroup(TaskGroup taskGroup)
{
TaskGroup tempTaskGroup;
try
{
var x = DataContext.TaskGroups.Attach(taskGroup);
var entry = DataContext.Entry(taskGroup);
if (!String.IsNullOrEmpty(taskGroup.Name))
{
entry.Property(e => e.Name).IsModified = true;
}
tempTaskGroup = x.Entity;
base.DataContext.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(tempTaskGroup);
}
public Manager(AutomataConfiguration configuration)
{
Dictionary <Type, ILogSink> logSinks = new Dictionary <Type, ILogSink>();
this.configuration = configuration;
if (this.configuration == null)
{
throw new ArgumentNullException("Configuration is null");
}
if (!this.configuration.HasConfiguration)
{
throw new Exception("Automata configuration is incomplete.");
}
foreach (var group in this.configuration.TaskGroups)
{
var taskGroup = new TaskGroup();
taskGroup.Name = group.Name;
var tasks = new List <ITask>();
if (!logSinks.ContainsKey(group.LogSink))
{
var logSink = (ILogSink)Activator.CreateInstance(group.LogSink);
Dictionary <string, string> logParameters = this.configuration.LogSinks.Where(s => s.LogSink == group.LogSink).FirstOrDefault()?.Parameters;
if (logParameters != null)
{
logSink.Configure(logParameters);
}
logSinks.Add(group.LogSink, logSink);
}
taskGroup.LogSink = logSinks[group.LogSink];
// create task here, and assign it the logsink from the dictionary
foreach (var task in group.Tasks)
{
var automationTask = (ITask)Activator.CreateInstance(task.Item2);
automationTask.LogSink = taskGroup.LogSink;
Dictionary <string, string> taskParameters = task.Item3;
if (taskParameters != null)
{
automationTask.Configure(taskParameters);
}
automationTask.Name = task.Item1;
automationTask.GroupName = taskGroup.Name;
tasks.Add(automationTask);
}
taskGroup.AutomationTasks = tasks.ToArray();
taskGroups.Add(taskGroup);
}
}
/// <summary>
/// Calculatee the gradients.
/// </summary>
public virtual void CalculateGradients()
{
if (this.workers == null)
{
Init();
}
this.workers[0].Network.ClearContext();
this.totalError = 0;
if (this.workers.Length > 1)
{
TaskGroup group = EngineConcurrency.Instance
.CreateTaskGroup();
/* foreach */
foreach (IFlatGradientWorker worker in this.workers)
{
EngineConcurrency.Instance.ProcessTask(worker, group);
}
group.WaitForComplete();
}
else
{
this.workers[0].Run();
}
this.currentError = this.totalError / this.workers.Length;
}
public async Task <int> AddAsync(TaskGroup group)
{
_context.TaskGroups.Add(group);
await _context.SaveChangesAsync();
return(group.TaskGroupId);
}
/// <summary>
/// Perform one generation.
/// </summary>
public virtual void Iteration()
{
int countToMate = (int)(Population.Genomes.Count * PercentToMate);
int offspringCount = countToMate * 2;
int offspringIndex = Population.Genomes.Count - offspringCount;
int matingPopulationSize = (int)(Population.Genomes.Count * MatingPopulation);
TaskGroup group = EngineConcurrency.Instance
.CreateTaskGroup();
// mate and form the next generation
for (int i = 0; i < countToMate; i++)
{
IGenome mother = Population.Genomes[i];
int fatherInt = (int)(ThreadSafeRandom.NextDouble() * matingPopulationSize);
IGenome father = Population.Genomes[fatherInt];
IGenome child1 = Population.Genomes[offspringIndex];
IGenome child2 = Population.Genomes[
offspringIndex + 1];
MateWorker worker = new MateWorker(mother, father, child1,
child2);
EngineConcurrency.Instance.ProcessTask(worker, group);
offspringIndex += 2;
}
group.WaitForComplete();
// sort the next generation
Population.Sort();
}
public async Task <ActionResult <TaskGroup> > PostProject(TaskGroup taskGroup)
{
this.context.TaskGroups.Add(taskGroup);
await this.context.SaveChangesAsync();
return(this.CreatedAtAction(nameof(this.GetGroup), new { groupID = taskGroup.ID }, taskGroup));
}
/// <summary>
/// Calculate the gradients.
/// </summary>
///
public virtual void CalculateGradients()
{
if (_workers == null)
{
Init();
}
if (_flat.HasContext)
{
_workers[0].Network.ClearContext();
}
_totalError = 0;
if (_workers.Length > 1)
{
TaskGroup group = EngineConcurrency.Instance
.CreateTaskGroup();
foreach (GradientWorker worker in _workers)
{
EngineConcurrency.Instance.ProcessTask(worker, group);
}
group.WaitForComplete();
}
else
{
_workers[0].Run();
}
CurrentError = _totalError / _workers.Length;
}
/// <summary>
/// 非同期タスクグループを作成する
/// </summary>
/// <param name="capacity">登録タスクキャパシティ</param>
/// <returns>作成したタスクグループインターフェイス</returns>
public ITaskGroup CreateAsyncTaskGroup(int capacity = 8, uint priority = DefaultPriority)
{
TaskGroup group = new TaskGroup(true, capacity, priority);
AddGroup(group);
return(group);
}
private List <BuildDefinitionStep> AddTasks(TaskGroup tg)
{
var steps = new List <BuildDefinitionStep>();
foreach (var t in tg.Tasks)
{
var step = new BuildDefinitionStep
{
TimeoutInMinutes = t.TimeoutInMinutes,
Condition = t.Condition,
DisplayName = t.DisplayName,
Environment = t.Environment,
AlwaysRun = t.AlwaysRun,
ContinueOnError = t.ContinueOnError,
Enabled = t.Enabled,
Inputs = t.Inputs,
TaskDefinition = new Microsoft.TeamFoundation.Build.WebApi.TaskDefinitionReference
{
DefinitionType = t.Task.DefinitionType,
Id = t.Task.Id,
VersionSpec = t.Task.VersionSpec
}
};
steps.Add(step);
}
return(steps);
}
public Context()
{
this.items = new List <ITask>();
this.groupAscending = true;
this.taskGroup = TaskGroup.DueDate;
}
public IActionResult TaskGroupCreate(AddTaskGroupViewModel addTaskGroup)
{
var check = _context.TaskGroups.Any(t => t.TaskGroupName == addTaskGroup.TaskGroupName);
if (check)
{
ModelState.AddModelError(string.Empty, "Tokia užduočių grupė jau yra sukurta");
return(View());
}
if (ModelState.IsValid)
{
//var newTaskGroup = new TaskGroup() { TaskGroupName = addTaskGroup.TaskGroupName, TaskGroupCount = addTaskGroup.TaskGroupCount };
var newTaskGroup = new TaskGroup()
{
TaskGroupName = addTaskGroup.TaskGroupName
};
if (newTaskGroup != null)
{
_context.TaskGroups.Add(newTaskGroup);
_context.SaveChanges();
}
return(RedirectToAction("TaskGroup"));
}
return(View());
}
public TaskGroupChoose(TaskGroup[] TaskArr)
{
InitializeComponent();
TaskGroupPanelList.Dock = DockStyle.Fill;
this.panel2.Controls.Add(TaskGroupPanelList);
SetGroup(TaskArr);
}
public async Task <ActionResult <TaskGroup> > PostTaskGroup(TaskGroup taskGroup)
{
_db.TaskGroups.Add(taskGroup);
await _db.SaveChangesAsync();
return(CreatedAtAction("GetTaskGroup", new { id = taskGroup.ID }, taskGroup));
}
public Boolean Delete(TaskGroup taskGroup)
{
_context.TaskGroups.Remove(taskGroup);
_context.SaveChanges();
_logger.LogInformation("Delete Task Group " + taskGroup.TaskGroupId + " " + taskGroup.Name);
return(true);
}
// TODO: Document
public static void CreateGroup(
string groupName,
int totalThreads,
bool @async,
System.Action <Dictionary <string, object> > onComplete)
{
// TODO: May need to terminate old threads on the old group if this is squashing it
var taskGroup = new TaskGroup {
Name = groupName,
Async = @async,
TotalThreads = totalThreads,
OnComplete = onComplete,
TaskRunners = new List <TaskRunner>(),
Results = new Dictionary <string, object>(),
};
groupSpecificTaskLock.Add(taskGroup, new ReaderWriterLockSlim());
groupLock.EnterWriteLock();
try {
groups.Add(groupName, taskGroup);
}
finally {
groupLock.ExitWriteLock();
}
}
public TaskGroup Save(TaskGroup taskGroup)
{
if (taskGroup.UserTasks != null)
{
try
{
taskGroup.UserTasks.ForEach(userTask => {
_context.Entry(userTask).State = EntityState.Modified;
//_context.Entry(userTask.User).State = EntityState.Detached;
});
}
catch (Exception ex)
{
_context.UserTasks.RemoveRange(taskGroup.UserTasks);
throw;
}
}
_context.TaskGroups.Add(taskGroup);
if (taskGroup.TaskGroupId > 0)
{
_context.Entry(taskGroup).State = EntityState.Modified;
}
_context.SaveChanges();
return(taskGroup);
}
public ActionResult PostEditTaskGroup(TaskGroup taskGroup)
{
db.Entry(taskGroup).State = EntityState.Modified;
db.SaveChanges();
return(Redirect("/TaskGroup/Index"));
}
public Environment(string luaToRun, ExtensionCollection extensionCollection)
{
var lua = new Lua();
var taskExtension = new TaskExtension();
taskExtension.LoadExtension(lua);
extensionCollection.LoadExtensions(lua);
lua.DoString(luaToRun);
var tasks = lua["Pipeline"];
if (tasks is null)
{
throw new PipelineNotFoundException();
}
if (tasks.GetType() != typeof(LuaTable))
{
return;
}
_statusUpdater = new StatusUpdater();
_rootTaskGroup = new TaskGroup((LuaTable)tasks);
_rootTaskGroup.Allow(_statusUpdater);
_statusUpdater.StatusUpdate += update => Update?.Invoke(update);
}
public async Task <IActionResult> PutTaskGroup(Guid id, TaskGroup taskGroup)
{
if (id != taskGroup.ID)
{
return(BadRequest());
}
_db.Entry(taskGroup).State = EntityState.Modified;
try
{
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskGroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ExceptionTest()
{
taskGroup = new TaskGroup
{
GroupName = "Academic Task",
Active = "Yes",
Color = "red"
};
taskItem = new TaskItem
{
Name = "Training",
Priority = TaskPriority.High,
TaskStatus = TaskStatus.Yet_To_Start,
TaskStartDate = DateTime.Now,
TaskEndDate = DateTime.Now.AddDays(5),
TaskGroup = "Academic Task",
TaskColorCode = "purple"
};
MongoDBUtility mongoDBUtility = new MongoDBUtility();
context = mongoDBUtility.MongoDBContext;
_taskRepository = new TaskRepository(context);
_taskService = new TaskService(_taskRepository);
config = new ConfigurationBuilder().AddJsonFile("appsettings.test.json").Build();
}
private static TaskGroupUpdateParameter GetTaskGroupUpdateParameter(TaskGroup taskGroup)
{
var taskGroupUpdateParameter = new TaskGroupUpdateParameter
{
Id = taskGroup.Id,
Name = taskGroup.Name,
Description = taskGroup.Description,
Comment = taskGroup.Comment,
ParentDefinitionId = taskGroup.ParentDefinitionId
};
if (taskGroup.Inputs.Any())
{
foreach (var input in taskGroup.Inputs)
{
taskGroupUpdateParameter.Inputs.Add(input);
}
}
if (taskGroup.Tasks.Any())
{
foreach (var task in taskGroup.Tasks)
{
taskGroupUpdateParameter.Tasks.Add(task);
}
}
return(taskGroupUpdateParameter);
}
public FolderBaseEntry(IAbstractFolder folder, string parameter = null)
{
this.Name = folder.Name;
this.GroupAscending = folder.GroupAscending;
this.Group = folder.TaskGroup;
this.Parameter = parameter;
}
public ActionResult PostAddTaskGroup(TaskGroup taskGroup)
{
db.TaskGroups.Add(taskGroup);
db.SaveChanges();
return(Redirect("/TaskGroup/Index"));
}
private void schedulerControl1_EditAppointmentFormShowing(object sender, AppointmentFormEventArgs e)
{
Task singletask = this.session1.GetObjectByKey <Task>(e.Appointment.Id);
if (singletask != null)
{
SetDefault();
using (RibbonFormNuovoTask form = new RibbonFormNuovoTask())
{
TaskGroup taskgruppo = singletask.Gruppo;
form.Init(taskgruppo);
if (form.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
this.xpCollectionTask.Reload();
this.schedulerStorage1.RefreshData();
NewTask = taskgruppo;
}
}
}
e.DialogResult = System.Windows.Forms.DialogResult.OK;
this.schedulerControl1.Refresh();
e.Handled = true;
}
public IActionResult Create(int id, int?taskVariantId)
{
string userId = _userManager.GetUserId(User);
TaskGroup taskGroup = _context.TaskGroups.Find(id);
if (!KaCakeUtils.IsCourseTeacher(_context, taskGroup.CourseId, userId))
{
return(Challenge());
}
TaskVariant editingTaskVariant;
if (taskVariantId.HasValue && (editingTaskVariant = _context.TaskVariants.Find(taskVariantId.Value)) != null)
{
return(View(new TaskVariantViewModel()
{
TaskGroupId = id,
Id = taskVariantId.Value,
Name = editingTaskVariant.Name,
Description = editingTaskVariant.Description,
IsUserTeacher = KaCakeUtils.IsCourseTeacher(_context, editingTaskVariant.TaskGroup.CourseId, userId)
}));
}
return(View(new TaskVariantViewModel
{
TaskGroupId = id,
IsUserTeacher = KaCakeUtils.IsCourseTeacher(_context, _context.TaskGroups.Find(id).CourseId, userId)
}));
}
public void Export(string fileName, DateTime dateFrom, DateTime dateTo, IEnumerable <TaskGroup> groups)
{
SpreadsheetInfo.SetLicense("E5M8-KYCM-HFC2-WRTR");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
if (groups == null)
{
throw new ApplicationException("no data");
}
var workbook = new ExcelFile();
// Create new worksheet and set cell A1 value to 'Hello world!'.
ExcelWorksheet ws = workbook.Worksheets.Add("TimeAnalytic");
int row = 0; //numeration starts from 0
WriteDate(ws, 1, "Date From", dateFrom);
WriteDate(ws, 2, "Date To", dateTo);
row = 4;
WriteGroupHeader(ws, row);
row++;
TaskGroup summary = groups.FirstOrDefault(x => x.IsSummary);
WriteGroupHeader(ws, row);
row = WriteGroups(ws, groups, summary, ref row);
row++;
row++;
WriteTasksHeader(ws, row);
WriteTasksForGroups(ws, groups, summary, ref row);
workbook.Save(fileName);
}
private void WriteGroupData(ExcelWorksheet ws, TaskGroup group, int row)
{
ws.Cells[row, (int)TaskGroupDataPosition.Title].Value = group.Title;
ws.Cells[row, (int)TaskGroupDataPosition.TotalEstimationDevelopment].Value = PrepareDouble(group.TotalEstimationDevelopment);
ws.Cells[row, (int)TaskGroupDataPosition.TotalEstimationDevelopment].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneEstimationDevelopment].Value = PrepareDouble(group.TotalDoneEstimationDevelopment);
ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneEstimationDevelopment].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneBookedDevelopment].Value = PrepareDouble(group.TotalDoneBookedDevelopment);
ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalTimeBooked].Value = PrepareDouble(group.TotalTimeBooked);
ws.Cells[row, (int)TaskGroupDataPosition.TotalTimeBooked].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedDevelopment].Value = PrepareDouble(group.TotalBookedDevelopment);
ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedMeetings].Value = PrepareDouble(group.TotalBookedMeetings);
ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedMeetings].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.TotalUnderEstimate].Value = PrepareDouble(group.TotalUnderEstimate);
ws.Cells[row, (int)TaskGroupDataPosition.TotalUnderEstimate].Style.NumberFormat = DOUBLE_FORMAT;
ws.Cells[row, (int)TaskGroupDataPosition.RateDoneBookedToBookedDevelopment].Value = PrepareDouble(group.RateDoneBookedToBookedDevelopment);
ws.Cells[row, (int)TaskGroupDataPosition.RateDoneBookedToBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT;
}
public FeedManager()
{
update_feed_map = new Dictionary<Feed, FeedUpdateTask> ();
update_task_list = new TaskList<FeedUpdateTask> ();
// Limit to 4 feeds downloading at a time
update_task_group = new TaskGroup<FeedUpdateTask> (2, update_task_list);
update_task_group.TaskStopped += OnUpdateTaskStopped;
update_task_group.TaskAssociated += OnUpdateTaskAdded;
// TODO
// Start timeout to refresh feeds every so often
}
public void TaskGroupFinishedSignal()
{
TaskGroup group = new TaskGroup();
group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskGroupFinishedSignal))));
group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskGroupFinishedSignal))));
ManualResetEvent resetEvent = new ManualResetEvent(false);
group.Finished += (sender, e) => resetEvent.Set();
group.Start();
if (!resetEvent.WaitOne(1000))
{
Assert.Fail();
}
}
public void ConcurrentTaskGroupStart()
{
TaskGroup group = new TaskGroup();
group = group.Add(new Task(() => Debug.WriteLine(nameof(ConcurrentTaskGroupStart))));
group = group.Add(new Task(() => Debug.WriteLine(nameof(ConcurrentTaskGroupStart))));
var t1 = new Task(() => group.Start());
var t2 = new Task(() => group.Start());
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
Assert.AreEqual(TaskStatus.RanToCompletion, t1.Status);
Assert.AreEqual(TaskStatus.RanToCompletion, t2.Status);
}
public void TaskCompletedSignal()
{
TaskGroup group = new TaskGroup();
int i = 0;
group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskCompletedSignal))));
group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskCompletedSignal))));
group.TaskCompleted += (sender, e) => Interlocked.Increment(ref i);
group.Start();
Thread.Sleep(1000);
if (i != 2)
{
Assert.Fail();
}
}
public void SetGroup(TaskGroup[] TaskArr)
{
List<FolderTrack.Types.TaskGroup> taskList = new List<FolderTrack.Types.TaskGroup>();
Dictionary<FolderTrack.Types.TaskGroup, object> TaskGroupTas;
TaskGroupTas = new Dictionary<TaskGroup, object>();
foreach (FolderTrack.Types.TaskGroup tas in TaskArr)
{
Util.DBug2("TaskGroupChoose", tas.TaskName);
taskList.Add(tas);
TaskGroupTas[tas] = tas;
}
foreach (FolderTrack.Types.TaskGroup gr in taskList)
{
foreach (FolderTrack.Types.Task t in gr.TaskList.Values)
{
Util.DBug2("TaskGroupChoose", t.Action + " " + t.Detail + " " + t.percent);
}
}
TaskGroupPanelList.SynchData(taskList);
TaskGroupPanelList.AddFunctionCallToData(TaskGroupTas);
}
public void ShowAllTask(TaskGroup[] task)
{
if (this.InvokeRequired)
{
this.Invoke(new VoidTaskGroupArrDelegate(ShowAllTask), new object[] { task });
return;
}
this.NoMonitorGroupPanel.Visible = false;
this.MonitorGrouPanLis.Visible = false;
this.EMonitorGrouPanLis.Visible = false;
this.taskChoose.Visible = true;
this.Monitpanel.Visible = true;
this.taskChoose.SetGroup(task);
}
public void Dispose(System.Threading.AutoResetEvent disposeHandle)
{
lock (update_task_group.SyncRoot) {
if (update_task_group != null) {
//update_task_group.CancelAsync ();
//update_task_group.Handle.WaitOne ();
update_task_group.Dispose ();
//disposeHandle.WaitOne ();
update_task_group.TaskStopped -= OnUpdateTaskStopped;
update_task_group.TaskAssociated -= OnUpdateTaskAdded;
update_task_group = null;
}
update_task_list = null;
disposed = true;
}
}
public void TaskUpdate(TaskGroup[] task)
{
bool allowHide = true;
if (CurrentTaskArr != null)
{
foreach (TaskGroup tas in CurrentTaskArr)
{
if (tas.Status == TaskGroup.FAILED)
{
allowHide = false;
break;
}
}
}
if (task == null && allowHide)
{
new Thread(HideTask).Start();
return;
}
if (task != null)
{
CurrentTaskArr = task;
}
foreach (TaskGroup tas in task)
{
Util.DBug2("TaskManager", tas.TaskName);
foreach (FolderTrack.Types.Task t in tas.TaskList.Values)
{
Util.DBug2("MainForm", t.Action + " " + t.Detail + " " + t.percent);
}
}
bool showAllTask = false;
if (this.taskChoose.Visible == false)
{
foreach (TaskGroup t in task)
{
if (t.Status == TaskGroup.PERSISTANT_FAIL)
{
showAllTask = true;
break;
}
foreach (FolderTrack.Types.Task ta in t.TaskList.Values)
{
if (ta.ErrorDiscrip != null)
{
showAllTask = true;
break;
}
}
if (showAllTask == true)
{
break;
}
}
}
else
{
showAllTask = true;
}
if (showAllTask)
{
ShowAllTask(task);
}
else
{
hideTaskButton = false;
new Thread(BlinkButton).Start();
}
}
public void TaskUpdate(TaskGroup[] task)
{
}
public DashboardTaskGroupProperty(TaskGroup taskGroup)
{
TaskGroup = taskGroup;
WorkingNode = TaskGroup.Owner;
}
public void TaskUpdate(TaskGroup[] task)
{
if(CallList == null)
{
return;
}
foreach (FolderTrackCallBack flCall in CallList)
{
try
{
flCall.TaskUpdate(task);
}
catch (Exception)
{
//Dont care
}
}
}
public void TaskUpdate(TaskGroup[] task)
{
foreach (FolderTrackCallBack flCall in CallList)
{
try
{
flCall.TaskUpdate(task);
}
catch (Exception)
{
//Don't care
}
}
}
public static DashboardTaskGroupProperty CreateTaskGroupProperty(TaskGroup taskGroup)
{
return new DashboardTaskGroupProperty(taskGroup);
}
///////////////////////////////
public void AddTaskGroup (TaskGroup group)
{
if (task_groups == null)
task_groups = new ArrayList ();
task_groups.Add (group);
}
