public TaskForm(TaskData data, TaskList lists)
{
InitializeComponent();
gTaskData = data;
gTaskList = lists;
foreach (var task in lists)
{
LogPathComboBox.Items.Add(task.LogPath);
ProjectPathComboBox.Items.Add(task.ProjectPath);
}
NameTextBox.Text = data.Name;
LogFolderTextBox.Text = data.LogFolder;
if (data.LogNumber == -1)
{
for (int i = 0; i <= lists.Count; i++)
{
if (lists.Cast<TaskData>().Count(t => t.LogNumber == i) == 0)
{
LogNumericUpDown.Value = i;
break;
}
}
}
else
{
LogNumericUpDown.Value = data.LogNumber;
}
}
public AddTasksListViewModel(Func<TaskList, AddTasksList> addTasksListsFactory)
{
base.DisplayName = WindowTitle;
_task = new TaskList();
_addTasksListsFactory = addTasksListsFactory;
}
public override void begin(float length, int chapters, int paragraph)
{
time_ = 0.0f;
this.over_ = false;
GameManager.GetInstance ().road._speed = 0.001f;
TaskList tl = new TaskList ();
for (int i = 0; i < _sentence.Length; ++i) {
tl.push (new TaskPack(talkTask(_sentence[i])));
}
for (int i = 0; i < _talk.Length; ++i) {
if(_close[i]){
tl.push (_talk[i].goOutTask ());
}else{
tl.push (_talk[i].closePopTask ());
}
}
TaskManager.PushBack (tl, delegate {
this.over_ = true;
GameManager.GetInstance ().road._speed = 1.0f;
});
TaskManager.Run (tl);
}
static Scheduler()
{
var lockStrategy = new LockStrategy(LockRecursionPolicy.SupportsRecursion);
ScheduleQueue = new TaskList<ScheduleHistory>(lockStrategy);
ScheduleInProgress = new TaskList<ScheduleHistory>(lockStrategy);
}
///<summary>Inserts one TaskList into the database. Returns the new priKey.</summary>
internal static long Insert(TaskList taskList)
{
if(DataConnection.DBtype==DatabaseType.Oracle) {
taskList.TaskListNum=DbHelper.GetNextOracleKey("tasklist","TaskListNum");
int loopcount=0;
while(loopcount<100){
try {
return Insert(taskList,true);
}
catch(Oracle.DataAccess.Client.OracleException ex){
if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
taskList.TaskListNum++;
loopcount++;
}
else{
throw ex;
}
}
}
throw new ApplicationException("Insert failed. Could not generate primary key.");
}
else {
return Insert(taskList,false);
}
}
public Task execute()
{
TaskList tl = new TaskList ();
tl.push (cutTask ());
tl.push (uploadTask ());
return tl;
}
public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
{
ILister lister = new Lister();
if (arguments.GetParameter(arguments.GetLength() - 1) == "--export")
lister = new HtmlLister();
lister.ListFiltered(tasklist.FilterTasks(arguments.GetParameter(1)), arguments.GetParameter(1));
}
///<summary>Inserts one TaskList into the database. Provides option to use the existing priKey.</summary>
internal static long Insert(TaskList taskList,bool useExistingPK)
{
if(!useExistingPK && PrefC.RandomKeys) {
taskList.TaskListNum=ReplicationServers.GetKey("tasklist","TaskListNum");
}
string command="INSERT INTO tasklist (";
if(useExistingPK || PrefC.RandomKeys) {
command+="TaskListNum,";
}
command+="Descript,Parent,DateTL,IsRepeating,DateType,FromNum,ObjectType,DateTimeEntry) VALUES(";
if(useExistingPK || PrefC.RandomKeys) {
command+=POut.Long(taskList.TaskListNum)+",";
}
command+=
"'"+POut.String(taskList.Descript)+"',"
+ POut.Long (taskList.Parent)+","
+ POut.Date (taskList.DateTL)+","
+ POut.Bool (taskList.IsRepeating)+","
+ POut.Int ((int)taskList.DateType)+","
+ POut.Long (taskList.FromNum)+","
+ POut.Int ((int)taskList.ObjectType)+","
+ DbHelper.Now()+")";
if(useExistingPK || PrefC.RandomKeys) {
Db.NonQ(command);
}
else {
taskList.TaskListNum=Db.NonQ(command,true);
}
return taskList.TaskListNum;
}
private Expander CreateUITasklist(TaskList list, Google.Apis.Tasks.v1.Data.Tasks tasks)
{
var expander = new Expander();
// Add a bold title.
expander.Header = list.Title;
expander.FontWeight = FontWeights.Bold;
// Add the taskItems (if applicable).
if (tasks.Items != null)
{
var container = new StackPanel();
foreach (CheckBox box in tasks.Items.Select(CreateUITask))
{
container.Children.Add(box);
}
expander.Content = container;
}
else
{
expander.Content = "There are no tasks in this list.";
}
return expander;
}
public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
{
FileIO loader = new FileIO();
if (tasklist.MarkAsDone(arguments.GetParameter(1)))
loader.SaveTasks(tasklist.GetTasks());
else
Console.WriteLine("No task with that id found to mark as done");
}
public static void Main(string[] args)
{
var console = new RealConsole();
var projectRepository = new ProjectRepository();
var taskRepository = new TaskRepository();
var taskList = new TaskList(console, projectRepository, taskRepository);
taskList.Run();
}
// Use this for initialization
void Start()
{
TaskList tl = new TaskList ();
for(int i = 0;i<_sentence.Length; ++i){
tl.push (_talk.popTask (_sentence[i]));
}
TaskManager.Run (tl);
}
public async Task TaskGenerateAsync(int count)
{
var connect = new SQLiteAsyncConnection(DataBaseFile);
var taskList = await connect.Table<TaskTable>().Take(count).ToListAsync();
taskList.Shuffle ();
var categoryList = await connect.Table<CategoryTable>().ToListAsync();
_tasks = new TaskList(taskList, categoryList);
}
public FixDeleteAction(TaskManagerNoteAddin addin, TaskList tasklist1, TaskList tasklist2, int line)
: base(addin)
{
Priority = false;
this.tasklist1 = tasklist1;
this.tasklist2 = tasklist2;
this.line = line;
}
public Task(string taskText, string creator, int taskId, TaskList parentTaskList)
{
Creator = creator;
TaskText = taskText;
TaskId = taskId;
ParentTaskList = parentTaskList;
UpdateStatus(parentTaskList.DefaultStatus);
}
public void visit(TaskList list)
{
DataClassesDataContext local = new DataClassesDataContext();
Lists newList = new Lists();
newList.Title = list.Name;
/*newList.Description = list.description;
newList.CreationDate = DateTime.Now;*/
}
public void Execute(ArgumentList arguments, TaskList tasks, TagList tags, TagFolder folder)
{
FileIO loader = new FileIO();
TaskTagger tagTasks = new TaskTagger(tasks.GetTasks());
if (tagTasks.Untag(arguments.GetParameter(1), arguments.GetParameter(2)))
loader.SaveTasks(tagTasks.GetTasks());
else
Console.WriteLine("No task with that id found to untag");
}
public void SelectMany()
{
string tempTaskFile = CreateTempTasksFile();
var tl = new TaskList(tempTaskFile);
IOrderedEnumerable<string> contexts = tl.SelectMany(task => task.Contexts,
(task, context) => context).Distinct().OrderBy(context => context);
Assert.AreEqual(3, contexts.Count());
}
public void Given()
{
_taskList = new TaskList<string>();
_container = new DefaultKernel();
ServiceLocator<string>.SetInstance(_container);
_container.Register(Component.For<TaskList<string>>().Instance(_taskList));
_container.Register(Component.For<SequentialBuilder<string>>().Instance(new SequentialBuilder<string>(_taskList)));
_container.Register(Component.For<WorkflowEngine<string>>().Instance(new WorkflowEngine<string>()));
_workflow = new Workflow<string>();
_function = new Func<bool>(RedOrangeYellow);
}
public EditTasksList(
TaskList tasksList,
TasksService tasksService,
IBusyIndicator busyIndicator,
DataContext dataContext)
{
_tasksList = tasksList;
_tasksService = tasksService;
_busyIndicator = busyIndicator;
_dataContext = dataContext;
}
public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
{
FileIO loader = new FileIO();
if (tasklist.RemoveTask(arguments.GetParameter(1)))
{
loader.SaveTasks(tasklist.GetTasks());
Console.WriteLine("Task " + arguments.GetParameter(1) + " removed.");
}
else
Console.WriteLine("No task with that id found to remove");
}
public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
{
ILister lister = new Lister();
if (arguments.GetParameter(arguments.GetLength() - 1) == "--export")
lister = new HtmlLister();
if (arguments.GetLength() == 1 || arguments.GetParameter(1) == "--export")
lister.ListNotDone(tasklist.GetTasks(), string.Empty);
else if (arguments.GetParameter(1) == "all")
lister.ListAllTasks(tasklist.GetTasks());
else if (arguments.GetParameter(1) == "tags")
lister.ListTags(tags, tasklist);
}
/// <summary>
/// Spawn a new process that is detached from the parent process of this
/// </summary>
/// <param name="text"></param>
public int Spawn(string text)
{
var TaskList = new TaskList("tcc");
//Tcc.ExecuteCmd(TccCommandName.START, "/B /C /PGM " + text + " <NUL");
var parts = Regex.Matches(text, @"[\""].+?[\""]|[^ ]+")
.Cast<Match>()
.Select(m => m.Value.Trim())
.ToList();
var exePath = FileHelper.FindInSearchPath(parts.First());
if (string.IsNullOrEmpty(exePath))
{
Console.WriteLine("Unable to find '{0}' in search path");
}
var task = new ProcessStartInfo(exePath);
task.Arguments = String.Join(" ", parts.Skip(1));
task.CreateNoWindow = true;
task.UseShellExecute=false;
task.RedirectStandardOutput = true;
task.RedirectStandardError = true;
task.StandardErrorEncoding = Encoding.UTF8;
task.StandardOutputEncoding= Encoding.UTF8;
var pr = new Process();
pr.StartInfo = task;
pr.ErrorDataReceived += process_DataReceived;
pr.OutputDataReceived += process_DataReceived;
pr.EnableRaisingEvents = true;
pr.Start();
pr.BeginErrorReadLine();
pr.BeginOutputReadLine();
//var processes = TaskList.Compare();
//Process process;
try {
//process = processes.Single();
//var pid = process.Id;
var pid = pr.Id;
LastPID = pid;
SpawnedPIDs.Add(pid);
return pid;
}
catch (Exception e)
{
Console.WriteLine("Unable to determine new process ID: "+ e.Message);
}
return -1;
}
// Use this for initialization
void Start()
{
TaskList tl = new TaskList ();
Task task1 = new Task ();
task1.init = delegate() {
Debug.Log("this is firs task!!!");
};
task1.isOver = delegate() {
return true;
};
tl.push (task1);
TaskWait wait = new TaskWait ();
wait.setAllTime (2f);
tl.push (wait);
Task task2 = new Task ();
task2.init = delegate() {
Debug.Log("this is second task!!!");
};
tl.push (task2);
TaskSet mt = new TaskSet ();
Task task3 = new Task ();
task3.init = delegate() {
Debug.Log("this is third task!!!");
};
task3.update = delegate(float d)
{
};
mt.push (task3);
Task task4 = new Task ();
task4.init = delegate() {
Debug.Log("this is four task!!!");
};
mt.push (task4);
TaskWait wait2 = new TaskWait ();
wait2.setAllTime (5f);
mt.push (wait2);
Task task5 = new Task ();
task5.init = delegate() {
Debug.Log("this is five task!!!");
};
mt.push (task5);
tl.push (mt);
TaskManager.Run (tl);
}
public void Add_Multiple()
{
var tl = new TaskList(_testDataPath);
int c = tl.Count();
var task = new Task("Add_Multiple task one");
tl.Add(task);
var task2 = new Task("Add_Multiple task two");
tl.Add(task2);
Assert.AreEqual(c + 2, tl.Count());
}
public TasksListViewModel(
TaskList taskList,
EventAggregator eventAggregator,
Func<string, LoadTasks> loadTasksFactory,
Func<TaskList, EditTasksList> editTasksListFactory,
Func<TaskList, DeleteTasksList> deleteTasksListsFactory)
{
_taskList = taskList;
_eventAggregator = eventAggregator;
_loadTasksFactory = loadTasksFactory;
_editTasksListFactory = editTasksListFactory;
_deleteTasksListsFactory = deleteTasksListsFactory;
}
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 Execute(ArgumentList arguments, TaskList tasks, TagList tags, TagFolder folder)
{
ILister lister = new Lister();
if (arguments.GetParameter(arguments.GetLength() - 1) == "--export")
lister = new HtmlLister();
if (arguments.GetLength() == 1 || arguments.GetParameter(1) == "--export")
lister.ListNotDone(tasks.FilterDue("past"), string.Empty);
else if (arguments.GetParameter(1) == "today")
lister.ListNotDone(tasks.FilterDue("today"), string.Empty);
else if (arguments.GetParameter(1) == "thisWeek")
lister.ListNotDone(tasks.FilterDue("thisWeek"), string.Empty);
else if (arguments.GetParameter(1) == "nextWeek")
lister.ListNotDone(tasks.FilterDue("nextWeek"), string.Empty);
}
public void TestMethod1()
{
TaskList tasklist = new TaskList();
TaskClass t = new TaskClass();
t.Name = "name";
t.Description = "sdfsdf";
t.Date = DateTime.Now;
var addWindow = new ToDoLIst.AddTask(t, tasklist);
Assert.Equals(tasklist.AllTasksList.Count , 1);
}
public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
{
if (tasklist.HasSameTask(arguments.GetParameter(1)) == false)
{
Task task = new Task();
FileIO loader = new FileIO();
task.TaskDescription = arguments.GetParameter(1);
task.IsNewTask = true;
task = CheckDueDate(arguments, task);
tasklist.AddTask(ref task);
loader.SaveTasks(tasklist.GetTasks());
Console.WriteLine("Task {0} added", task.TaskDescription);
}
else Console.WriteLine("Task already in list");
}
public void Delete_InCollection()
{
var task = new Task("(B) Delete_InCollection +test @task");
var tl = new TaskList(Data.TestDataPath);
tl.Add(task);
var tasks = new List <Task>(tl.Tasks);
tasks.Remove(tasks.Where(x => x.Raw == task.Raw).First());
tl.Delete(task);
var newTasks = tl.Tasks.ToList();
Assert.AreEqual(tasks.Count, newTasks.Count);
for (int i = 0; i < tasks.Count; i++)
{
Assert.AreEqual(tasks[i].ToString(), newTasks[i].ToString());
}
}
public bool WriteTableContent(TaskList tasks, HtmlTextWriter html)
{
if (!Enabled)
{
return(false);
}
if (SeparatePage)
{
html.AddAttribute("class", "title-page");
}
html.RenderBeginTag(HtmlTextWriterTag.Div);
var title = Text.Replace("$(reportTitle)", tasks.GetReportTitle());
title = title.Replace("$(reportDate)", tasks.GetReportDate());
html.Write(title);
html.RenderEndTag(); // Div
return(true);
}
public TaskList generateTaskList(Console[] consoles)
{
List <string> cc = new List <string>();
foreach (Console x in consoles)
{
cc.Add(x.ToString());
}
List <string> machines = new List <string>();
TaskList result = new TaskList();
System.Random rnd = new System.Random();
for (int i = 0; i < this.task_number; i++)
{
var index = rnd.Next(cc.Count);
result.Add(cc[index], "A");
cc.RemoveAt(index);
}
return(result);
}
protected override void OnActivated()
{
base.OnActivated();
MainClass.MainWindow.ProcessOutput.Clear();
MainClass.MainWindow.ErrorOutput.Clear();
if (MainClass.Settings.ClearConsoleBeforRuning)
{
MainClass.MainWindow.OutputConsole.Clear();
}
TaskList tl = new TaskList();
tl.TasksList = new System.Collections.Generic.List <Moscrif.IDE.Task.ITask>();
CompileTask ct = new CompileTask();
tl.TasksList.Add(ct);
MainClass.MainWindow.RunTaskList(tl, false);
return;
}
public NoteForm(TaskList taskList)
{
InitializeComponent();
this.taskList = taskList;
// Set the title.
Text = taskList.Title;
// Load all notes:
Tasks tasks = Program.Service.Tasks.List(taskList.Id).Execute();
if (tasks.Items != null)
{
foreach (Task task in tasks.Items)
{
AddNote(task);
}
}
else
{
AddNote();
}
}
///<summary>Recursively returns a list of all leaf nodes down stream from the given parent taskListNode.</summary>
private List <TaskList> GetLeafSubsFromTask(TaskList taskListNode, List <TaskList> listTaskListSubs)
{
List <TaskList> children = TaskLists.RefreshChildren(taskListNode.TaskListNum, Security.CurUser.UserNum, Security.CurUser.TaskListInBox, TaskType.All);
if (children.Count == 0) //base case: is a leaf
{
return(new List <TaskList>()
{
taskListNode
});
}
List <TaskList> listLeaves = new List <TaskList>();
foreach (TaskList child in children)
{
if (listTaskListSubs.Contains(child)) //This node is already in our list of tasklist subscriptions
{
continue; //Avoid traversing the same route down the tree twice, reduces Db calls.
}
listLeaves.AddRange(GetLeafSubsFromTask(child, listTaskListSubs));
}
return(listLeaves);
}
public void Delete(int position)
{
if (position == 0)
{
_head = _head.Next;
}
else
{
TaskList tempBL = _head;
TaskList prev = _head;
for (int i = 0; i < position + 1; ++i)
{
if (position > 0 && i == position - 1)
{
prev = tempBL;
}
tempBL = tempBL.Next;
}
prev.Next = tempBL;
}
Length--;
GC.Collect();
}
public List <TaskListItem> ListTaskListItems(TaskList taskList)
{
List <TaskListItem> listTaskListItems = new List <TaskListItem>();
ToDoContext dbContext = new ToDoContext();
var taskListFromDb = dbContext.TaskLists.Where(i => i.Id == taskList.Id).SingleOrDefault();
List <TaskListItem> taskListItems = dbContext.TaskListItems.Where(n => n.TaskList.Id == taskList.Id).ToList();
if (taskListItems != null && taskListFromDb.User.Id == _securityManager.GetLoggedUserId())
{
_logManager.Info("Listing Tasks in Task List");
foreach (TaskListItem taskListItem in taskListItems)
{
listTaskListItems.Add(taskListItem);
}
return(listTaskListItems);
}
else
{
_logManager.Error("Task List Items not displayed");
_logManager.Debug("User info who failed listing: " + taskList.Id + " " + taskList.Name);
return(listTaskListItems);
}
}
internal static TaskList gatTaskList(HttpResponseMessage responce)
{
var taskList = new TaskList();
var jsonObj = JsonConvert.DeserializeObject <Dictionary <string, object> >(responce.Content.ReadAsStringAsync().Result);
if (jsonObj.ContainsKey("task"))
{
var tasksArray = JsonConvert.DeserializeObject <List <object> >(jsonObj["task"].ToString());
foreach (var taskObj in tasksArray)
{
var task = new ProjectTask();
task = JsonConvert.DeserializeObject <ProjectTask>(taskObj.ToString());
taskList.Add(task);
}
}
if (jsonObj.ContainsKey("page_context"))
{
var pageContext = new PageContext();
pageContext = JsonConvert.DeserializeObject <PageContext>(jsonObj["page_context"].ToString());
taskList.page_context = pageContext;
}
return(taskList);
}
private List <Task> CreateModel()
{
TaskList tasks = new TaskList();
var items = Context.Database.GetItem("{ED3BC3C1-43DB-4FE3-92CD-066401F1773A}").GetChildren(Collections.ChildListOptions.SkipSorting).ToArray();
foreach (Data.Items.Item item in items)
{
{
Task t = new Task()
{
Name = new HtmlString(item.Name),
Category = new HtmlString(FieldRenderer.Render(item, "category")),
Description = new HtmlString(FieldRenderer.Render(item, "description")),
Details = new HtmlString(FieldRenderer.Render(item, "details")),
DueDate = new HtmlString(FieldRenderer.Render(item, "datedue", "format=dd/MM/yyyy")),
Status = new HtmlString(FieldRenderer.Render(item, "status")),
Url = new HtmlString(LinkManager.GetItemUrl(item))
};
tasks.Add(t);
}
}
return(tasks);
}
public async Task <List <ProjectTask> > GetTfsTasks(Guid projectId, string tfsTaskIds)
{
Entity project = await Task.Run(() => service.Retrieve("bvrcrm_project", projectId,
new ColumnSet("bvrcrm_tfs_url", "bvrcrm_customer", "bvrcrm_tfs_access_token")));
var personalAccessToken = project.GetAttributeValue <string>("bvrcrm_tfs_access_token");
var tfsUrl = project.GetAttributeValue <string>("bvrcrm_tfs_url");
TfsConnector tfsConnector = new TfsConnector(personalAccessToken, tfsUrl);
TaskList tfsTasks = await tfsConnector.GetTasksFromTfs(tfsTaskIds);
List <ProjectTask> tasks = new List <ProjectTask>();
foreach (TaskItem tfsTask in tfsTasks.Value)
{
ProjectTask task = await GetTaskFromTfsTask(tfsTask);
tasks.Add(task);
}
return(tasks);
}
private void RemoveSelectedTasks()
{
if (_selectedTasks.Count == 0)
{
return;
}
_workingWithSelectedTasks = true;
foreach (var task in _selectedTasks)
{
if (task != null)
{
TaskList.Delete(task);
}
}
_selectedTasks.Clear();
_taskFileService.SaveTasks();
_workingWithSelectedTasks = false;
}
/// <summary>
/// タスクのオブジェクト名を一意にする為の一意のキーを生成
/// <summary>
public int CreateUniqueKey(TaskList tasks)
{
var list = tasks.list;
if (list.Count != 0)
{
Debug.Log("listの中身が空ではない場合");
List <int> AllKeys = new List <int>();
foreach (var task in list)
{
AllKeys.Add(task.id);
}
int maxKey = AllKeys.Max();
var uniqueKey = ++maxKey;
return(uniqueKey);
}
else
{
Debug.Log("listの中身が空の場合");
return(1);
}
}
/// <summary>
/// Base method for all tasks..
/// Adds each task to the task manager list
/// </summary>
protected Task()
{
if (TaskList.Count > 0)
{
for (int i = 0; i < TaskList.Count; i++)
{
if (TaskList[i].taskID != TaskList.Count)
{
_taskID = TaskList.Count;
}
else
{
_taskID = TaskList.Count + 1;
}
}
}
else
{
_taskID = 0;
}
TaskList.Add(this);
}
private void File_Archive_Completed(object sender, RoutedEventArgs e)
{
if (!File.Exists(User.Default.ArchiveFilePath))
{
File_Options(this, null);
}
if (!File.Exists(User.Default.ArchiveFilePath))
{
return;
}
var archiveList = new TaskList(User.Default.ArchiveFilePath);
var completed = _taskList.Tasks.Where(t => t.Completed);
foreach (var task in completed)
{
archiveList.Add(task);
_taskList.Delete(task);
}
FilterAndSort(_currentSort);
}
public void ArchiveCompleted()
{
if (!File.Exists(User.Default.ArchiveFilePath))
{
ShowOptionsDialog();
}
if (!File.Exists(User.Default.ArchiveFilePath))
{
return;
}
var archiveList = new TaskList(User.Default.ArchiveFilePath);
var completed = _taskList.Tasks.Where(t => t.Completed);
foreach (var task in completed)
{
archiveList.Add(task);
_taskList.Delete(task);
}
UpdateDisplayedTasks();
}
/// <summary>
/// Disposes all TaskDistributor, worker threads, resources and remaining tasks.
/// </summary>
public override void Dispose()
{
while (true)
{
TaskBase currentTask;
lock (TaskList)
{
if (TaskList.Count != 0)
{
currentTask = TaskList[0];
TaskList.RemoveAt(0);
}
else
{
break;
}
}
currentTask.Dispose();
}
lock (workerThreads)
{
foreach (TaskWorker t in workerThreads)
{
t.Dispose();
}
workerThreads = new TaskWorker[0];
}
DataEvent.Close();
DataEvent = null;
if (mainTaskDistributor == this)
{
mainTaskDistributor = null;
}
}
private void UpdateTaskAttributes(TaskList tasks)
{
var rootItem = TaskItem(RootNode);
// A root item must already exist
if (rootItem == null)
{
return;
}
var changedTaskIds = new HashSet <UInt32>();
Task task = tasks.GetFirstTask();
while (task.IsValid() && ProcessTaskUpdate(task, changedTaskIds))
{
task = task.GetNextTask();
}
if (tasks.IsAttributeAvailable(Task.Attribute.Title))
{
foreach (var id in changedTaskIds)
{
RefreshNodeLabel(id, false);
}
}
if (tasks.IsAttributeAvailable(Task.Attribute.DoneDate))
{
foreach (var id in changedTaskIds)
{
var node = FindNode(id);
RefreshItemFont(node, false);
}
}
RecalculatePositions();
}
public async Task GetAllTasksByCaseworkerIdSuccess()
{
//Arrange
var helperHttpClientMoq = new Mock <ICaseworkerHttpClientHelper>();
var id = It.IsAny <Guid>();
var pageNumber = 1;
var caseworkerId = It.IsAny <string>();
var context = GetContext();
var _config = GetConifg();
var TaskData = new List <TaskDataResponseModel>()
{
new TaskDataResponseModel(id, It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>(), It.IsAny <DateTime>(),
It.IsAny <TaskState>(), It.IsAny <IReadOnlyList <AssignedActors> >(), It.IsAny <Reference>())
};
var responseData = new TaskList()
{
TotalNoOfPages = 1,
TotalSearchCount = 1,
PageNo = 1,
Result = TaskData
};
helperHttpClientMoq.Setup(x => x.GetAllTasksByCaseworkerIdFromMomentumCoreAsync("/tasks/filtered", pageNumber, caseworkerId))
.Returns(Task.FromResult(new ResultOrHttpError <TaskList, Error>(responseData)));
var caseworkerService = new CaseworkerService(_config, helperHttpClientMoq.Object, context.Object);
//Act
var result = await caseworkerService.GetAllTasksForCaseworkerIdAsync(caseworkerId, pageNumber).ConfigureAwait(false);
//Asert
result.Should().NotBeNull();
result.IsError.Should().BeFalse();
result.Result.Should().BeEquivalentTo(responseData);
}
/// <summary>
/// Adds the task to the list with connectionId id and cancellation token
/// </summary>
/// <param name="connectionId">The socket identifier.</param>
/// <param name="token">The token.</param>
public string AddTask(string connectionId, CancellationTokenSource token)
{
if (string.IsNullOrEmpty(connectionId) || token == null)
{
throw new ArgumentNullException(nameof(connectionId) + " or " + nameof(token));
}
var taskId = Guid.NewGuid().ToString();
if (TaskList.ContainsKey(connectionId))
{
if (TaskList.TryGetValue(connectionId, out var set))
{
set.Add(new WebSocketTask
{
CancellationTokenSource = token,
TaskId = taskId,
ConnectionId = connectionId,
TaskCompletion = new TaskCompletionSource <bool>()
});
}
}
else
{
TaskList.TryAdd(connectionId,
new HashSet <WebSocketTask>
{
new WebSocketTask
{
CancellationTokenSource = token,
TaskId = taskId,
ConnectionId = connectionId,
TaskCompletion = new TaskCompletionSource <bool>()
}
});
}
return(taskId);
}
public void RemoveEntity(IStoryEntityObject obj)
{
if (obj == null)
{
return;
}
if ((obj as IActor) != null)
{
ActorList.Remove(obj as IActor);
return;
}
if ((obj as IEvent) != null)
{
EventList.Remove(obj as IEvent);
return;
}
if ((obj as IStuff) != null)
{
StuffList.Remove(obj as IStuff);
return;
}
if ((obj as IGroup) != null)
{
GroupList.Remove(obj as IGroup);
return;
}
if ((obj as ITask) != null)
{
TaskList.Remove(obj as ITask);
return;
}
if ((obj as ILocation) != null)
{
LocationList.Remove(obj as ILocation);
return;
}
}
public void UpdateTasks(TaskList tasks, UIExtension.UpdateType type)
{
switch (type)
{
case UIExtension.UpdateType.Delete:
case UIExtension.UpdateType.All:
// Rebuild
m_Items.Clear();
m_MaxTaskID = 0;
SelectedAppointment = null;
break;
case UIExtension.UpdateType.New:
case UIExtension.UpdateType.Edit:
// In-place update
break;
}
// Update the tasks
Task task = tasks.GetFirstTask();
while (task.IsValid() && ProcessTaskUpdate(task, type))
{
task = task.GetNextTask();
}
// Scroll to the selected item if it was modified and is 'visible'
if (tasks.HasTask(m_SelectedTaskID) && IsTaskDisplayable(m_SelectedTaskID))
{
EnsureVisible(SelectedAppointment, true);
}
SelectionStart = SelectionEnd;
AdjustVScrollbar();
Invalidate();
}
public ToDoController(
IConfigService configService,
TaskList taskList,
string archiveFilePath,
IDictionary <string, ITodoCommand> commands,
ITaskListView taskListView)
{
_configService = configService;
_commands = commands;
_taskListView = taskListView;
_archiveFilePath = archiveFilePath;
_context = new CommandContext()
{
TaskList = taskList,
DebugLevel = Int32.Parse(configService.GetValue("debug_level")),
GroupByType = DotNetExtensions.ParseEnum <GroupByType>(configService.GetValue(ConfigService.GROUP_BY_TYPE_KEY), GroupByType.None),
SortType = DotNetExtensions.ParseEnum <SortType>(configService.GetValue(ConfigService.SORT_TYPE_KEY), SortType.Project),
Filter = new TaskFilter(configService.GetValue(ConfigService.FILTER_TEXT_KEY)),
};
Console.WriteLine($"Command context: DebugLevel: {_context.DebugLevel}, GroupByType: {_context.GroupByType.ToString()}, SortType: {_context.SortType.ToString()}, Filter: {_context.Filter}");
bool listOnStart;
if (Boolean.TryParse(configService.GetValue("list_on_start"), out listOnStart))
{
_context.ListOnStart = listOnStart;
}
bool listAfterCommand;
if (Boolean.TryParse(configService.GetValue("list_after_command"), out listAfterCommand))
{
_context.ListAfterCommand = listAfterCommand;
}
}
///<summary>Inserts one TaskList into the database. Provides option to use the existing priKey. Doesn't use the cache.</summary>
public static long InsertNoCache(TaskList taskList, bool useExistingPK)
{
bool isRandomKeys = Prefs.GetBoolNoCache(PrefName.RandomPrimaryKeys);
string command = "INSERT INTO tasklist (";
if (!useExistingPK && isRandomKeys)
{
taskList.TaskListNum = ReplicationServers.GetKeyNoCache("tasklist", "TaskListNum");
}
if (isRandomKeys || useExistingPK)
{
command += "TaskListNum,";
}
command += "Descript,Parent,DateTL,IsRepeating,DateType,FromNum,ObjectType,DateTimeEntry) VALUES(";
if (isRandomKeys || useExistingPK)
{
command += POut.Long(taskList.TaskListNum) + ",";
}
command +=
"'" + POut.String(taskList.Descript) + "',"
+ POut.Long(taskList.Parent) + ","
+ POut.Date(taskList.DateTL) + ","
+ POut.Bool(taskList.IsRepeating) + ","
+ POut.Int((int)taskList.DateType) + ","
+ POut.Long(taskList.FromNum) + ","
+ POut.Int((int)taskList.ObjectType) + ","
+ DbHelper.Now() + ")";
if (useExistingPK || isRandomKeys)
{
Db.NonQ(command);
}
else
{
taskList.TaskListNum = Db.NonQ(command, true, "TaskListNum", "taskList");
}
return(taskList.TaskListNum);
}
/// <summary>
/// Método que insere ou atualiza uma task
/// </summary>
/// <param name="taskListRequest" type="TaskList"></param>
/// <returns>Json com as propriedades Id da task, title da task, description da tasj e message de erro</returns>
public async Task <IHttpActionResult> Post(TaskList taskListRequest)
{
string menssage;
int id = 0;
string title = "";
string description = "";
try
{
Context context = new Context();
if (taskListRequest.id == 0)
{
context.TaskList.Add(taskListRequest);
}
else
{
context.TaskList.Attach(taskListRequest);
context.Entry(taskListRequest).State = EntityState.Modified;
}
context.SaveChanges();
id = taskListRequest.id;
title = taskListRequest.title;
description = taskListRequest.description;
context.Dispose();
menssage = "Task salva com sucesso";
}
catch (Exception ex)
{
menssage = ex.Message;
}
return(Json(new { id = id, title = title, description = description, menssage = menssage }));
}
public void TestSetSelectedTaskList()
{
ToDoApp testPracticeApp = new ToDoApp();
TaskList testTaskList = new TaskList()
{
Name = "Test Task List",
Description = "Testing the Task List",
};
testPracticeApp.CurrentTaskLists.Add(testTaskList);
testPracticeApp.SetSelectedTaskList(testTaskList.Id);
string expectedName = testTaskList.Name;
string expectedDesc = testTaskList.Description;
Guid? expectedId = testTaskList.Id;
string actualName = testPracticeApp.SelectedTaskList.Name;
string actualDesc = testPracticeApp.SelectedTaskList.Description;
Guid? actualId = testPracticeApp.SelectedTaskList.Id;
Assert.AreEqual(expectedName, actualName);
Assert.AreEqual(expectedDesc, actualDesc);
Assert.AreEqual(expectedId, actualId);
}
// --------------------------------------------------------------
public HtmlReportTemplateForm(String typeId, Translator trans, TaskList tasks, Preferences prefs, String key)
{
m_TypeId = typeId;
m_Trans = trans;
m_Tasklist = tasks;
m_Prefs = prefs;
m_PrefsKey = key;
m_Template = new HtmlReportTemplate();
m_PrevTemplate = new HtmlReportTemplate();
m_TemplateFilePath = prefs.GetProfileString(key, "LastOpenTemplate", "");
if (!m_Template.Load(m_TemplateFilePath))
{
m_TemplateFilePath = String.Empty;
}
m_ChangeTimer = new Timer();
m_ChangeTimer.Tick += new EventHandler(OnChangeTimer);
m_ChangeTimer.Interval = 500;
InitializeComponent();
}
public void Search()
{
string tempTasksFile = CreateTempTasksFile();
var tl = new TaskList(tempTasksFile);
// There should be two task which contain the term 'foo'
TaskList fooTaskList = tl.Search("foo");
Assert.IsNotNull(fooTaskList);
Assert.AreEqual(2, fooTaskList.Count);
// Search should be case insenstive
TaskList caseInsensitiveTaskList = tl.Search("Foo");
Assert.IsNotNull(caseInsensitiveTaskList);
Assert.AreEqual(2, caseInsensitiveTaskList.Count);
// '-' in front of the term should find all tasks without the term
TaskList notFooTaskList = tl.Search("-foo");
// So searching the list generated by the negative search for the term
// should give us an empty list
Assert.AreEqual(0, notFooTaskList.Search("foo").Count);
}
public void ObservableChanges()
{
var tl = new TaskList();
bool fired = false;
tl.CollectionChanged += (sender, e) => { fired = true; };
tl.LoadTasks(_testDataPath);
Assert.True(fired);
fired = false;
tl.Add(new Task("T", null, null, "Test task for observablecollection event firing"));
Assert.True(fired);
fired = false;
tl[0].PropertyChanged += (sender, e) => { fired = true; };
tl[0].Append("Test append for propertychanged event firing");
Assert.True(fired);
}
public void Save_To_Stream()
{
string tempTaskFile = CreateTempTasksFile();
var tl = new TaskList();
using (FileStream fs = File.OpenRead(tempTaskFile))
{
tl.LoadTasks(fs);
}
tl.Add(new Task("This task should end up in both lists"));
string tempTaskFileCopy = CreateTempTasksFile();
using (FileStream fs = File.OpenWrite(tempTaskFileCopy))
{
tl.SaveTasks(fs);
}
var tl2 = new TaskList(tempTaskFileCopy);
Assert.AreEqual(tl.Count, tl2.Count);
}
