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); }