From 52b69601625cac061b0a9faee0e82bde279f75c9 Mon Sep 17 00:00:00 2001 From: liyunze <50455574+liyunze-coding@users.noreply.github.com> Date: Wed, 18 Feb 2026 15:30:10 +1100 Subject: [PATCH] first commit --- .gitignore | 1 + Code.cs | 1135 ++++++++++++++++++++++++++++++++++++++ README.md | 90 +++ RythonTaskBot.sb | 1 + images/import-button.png | Bin 0 -> 22232 bytes images/imported.png | Bin 0 -> 59161 bytes 6 files changed, 1227 insertions(+) create mode 100644 .gitignore create mode 100644 Code.cs create mode 100644 README.md create mode 100644 RythonTaskBot.sb create mode 100644 images/import-button.png create mode 100644 images/imported.png diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a9d34b8 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +notes.md \ No newline at end of file diff --git a/Code.cs b/Code.cs new file mode 100644 index 0000000..be3a26a --- /dev/null +++ b/Code.cs @@ -0,0 +1,1135 @@ +using Streamer.bot.Plugin.Interface; +using Streamer.bot.Plugin.Interface.Model; +using Streamer.bot.Plugin.Interface.Enums; +using Streamer.bot.Common.Events; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +using System.Reflection; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; + +/* +Todo + +delete based on days + +{ + platform-userId: { + username: string + tasks: [ + name + completed? + timestamp added + timestamp completed + ], + totalIncompleteCount: uint + totalCompletedCount: uint + } + task-data +} +*/ +class Task +{ + public string Name; + public bool Completed; + public bool Focused; + public DateTime AddedTime; + public DateTime UpdatedTime; + public DateTime? CompletedTime; + public Task(string Name, bool Completed = false, bool Focused = false) + { + this.Name = Name; + this.Completed = Completed; + this.Focused = Focused; + this.AddedTime = DateTime.Now; + this.UpdatedTime = DateTime.Now; + } +} + +class UserData +{ + public string username; + public List tasks; + public uint totalIncompleteCount; + public uint totalCompletedCount; + public UserData(List tasks, string username) + { + this.username = username; + this.tasks = tasks; + this.totalIncompleteCount = 0; + this.totalCompletedCount = 0; + } +} + +public class Response +{ + public bool Success { get; set; } + public string ErrorMsg { get; set; } + + public Response(bool success, string errorMsg = null) + { + this.Success = success; + this.ErrorMsg = errorMsg; + } +} + +public class Response : Response +{ + public T Data { get; set; } + + public Response(bool success, T data = default(T), string errorMsg = null) : base(success, errorMsg) + { + this.Data = data; + } +} + +public class CPHInline +{ + private int characterLimit = 450; + private Dictionary taskData = new Dictionary(); + public char[] separators = + { + '|', + ',', + ';' + }; + public void Init() + { + // task list + string taskDataString = CPH.GetGlobalVar("rython-task-bot", true); + Dictionary taskListData = JsonConvert.DeserializeObject>(taskDataString); + this.taskData = taskListData; + Cleanup(false); + } + + // Send changes to frontend + private void Broadcast(T t, string? key = null) + { + // INDEX MUST BE TRUE INDEX + string json = JsonConvert.SerializeObject(new { source = "rython-task-bot", id = key ?? GetKey(), body = t, username = GetUsername() }); + CPH.WebsocketBroadcastJson(json); + } + + private List GetStreamerUsernames() + { + TwitchUserInfo twitchInfo = CPH.TwitchGetBroadcaster(); + var youtubeInfo = CPH.YouTubeGetBroadcaster(); + List usernames = new() + { + twitchInfo.UserName, + youtubeInfo.UserName + }; + return usernames; + } + + private string GetUsername(string? key = null) + { + if (String.IsNullOrEmpty(key)) + { + CPH.TryGetArg("user", out string username); + return username; + } + else + { + return this.taskData[key].username; + } + + return ""; + } + + private void SaveTasks() + { + string taskDataString = JsonConvert.SerializeObject(this.taskData); + CPH.SetGlobalVar("rython-task-bot", taskDataString, true); + } + + private void SaveIntoTasks(List tasks) + { + string key = GetKey(); + this.taskData[key].username = GetUsername(); + this.taskData[key].tasks = tasks; + SaveTasks(); + } + + private void Respond(string message) + { + CPH.TryGetArg("userType", out string platform); + switch (platform) + { + case "twitch": + CPH.TryGetArg("msgId", out string msgId); + CPH.TwitchReplyToMessage(message, msgId); + break; + case "youtube": + CPH.TryGetArg("user", out string YTUser); + CPH.SendYouTubeMessage($"@{YTUser} {message}"); + break; + default: + // idk i don't stream elsewhere + break; + } + } + + private List SplitTasks(string tasks) + { + return tasks.Split(separators, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()).ToList(); + } + + private string GetKey(string? username = null) + { + if (!String.IsNullOrEmpty(username)) + { + if (username[0] == '@') + { + username = username.Substring(1); + } + + // dig through task data, find username, case insensitive + foreach (var item in this.taskData) + { + if (item.Value.username.Equals(username, StringComparison.OrdinalIgnoreCase)) + { + return item.Key; + } + } + + return ""; + } + else + { + CPH.TryGetArg("userType", out string platform); + CPH.TryGetArg("userId", out string userId); + string key = $"{platform}-{userId}"; + return key; + } + } + + // ADD COMMAND + // <(true index, task name)> + private Response<(int, string)> AddTask(string taskName, bool completed = false, bool focused = false) + { + taskName = taskName.Trim(); + // Validation + if (string.IsNullOrEmpty(taskName)) + return new Response<(int, string)>(false, default, "Task cannot be empty"); + if (int.TryParse(taskName, out _)) + return new Response<(int, string)>(false, default, $"'{taskName}' cannot be a number"); + // Ensure user data exists + string key = GetKey(); + if (!this.taskData.ContainsKey(key)) + { + string username = GetUsername(); + this.taskData.Add(key, new UserData(new List(), username)); + } + + // Check for duplicate incomplete task + if (this.taskData[key].tasks.Any(t => t.Name.Equals(taskName, StringComparison.OrdinalIgnoreCase) && !t.Completed)) + return new Response<(int, string)>(false, default, $"Error: Task '{taskName}' already exists"); + // Add task + this.taskData[key].username = GetUsername(); + this.taskData[key].tasks.Add(new Task(taskName, completed, focused)); + int newIndex = this.taskData[key].tasks.Count - 1; // 1-based index for display + Broadcast(new { mode = "add", task = taskName, completed = completed, focused = focused }); + return new Response<(int, string)>(true, (newIndex, taskName), null); + } + + public bool AddCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + List taskStrings = SplitTasks(rawInput); + if (taskStrings.Count == 0) + { + Respond("No tasks provided"); + return false; + } + + List added = new(); + List<(string, string)> failed = new(); + foreach (string taskString in taskStrings) + { + var response = AddTask(taskString); + if (response.Success) + added.Add($"{response.Data.Item1 + 1}. {taskString.Trim()}"); + else + failed.Add((taskString, response.ErrorMsg)); + } + + // Save once after all tasks are processed + if (added.Count > 0) + { + SaveTasks(); + } + + // Build response + Respond(BuildAddResponseMessage(added, failed)); + return true; + } + + public bool LogCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + List taskStrings = SplitTasks(rawInput); + if (taskStrings.Count == 0) + { + Respond("Error: No tasks provided"); + return false; + } + + List logged = new(); + List<(string, string)> failed = new(); + foreach (string taskString in taskStrings) + { + var response = AddTask(taskString, true, false); + if (response.Success) + logged.Add($"{response.Data.Item1 + 1}. {taskString.Trim()}"); + else + failed.Add((taskString, response.ErrorMsg)); + } + + // Save once after all tasks are processed + if (logged.Count > 0) + { + SaveTasks(); + } + + // Build response + Respond(BuildLogResponseMessage(logged, failed)); + return true; + } + + private string BuildAddResponseMessage(List added, List<(string, string)> failed) + { + string response = "No tasks to add"; + if (added.Count > 0 && failed.Count == 0) + { + response = $"Added: {String.Join(" | ", added)}"; + if (response.Length > characterLimit) + { + response = "All the tasks have been added!"; + } + } + else if (added.Count == 0 && failed.Count == 1) + { + response = failed[0].Item2; // Single error, show the reason + } + else if (added.Count == 0 && failed.Count > 1) + { + response = $"Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; + if (response.Length > characterLimit) + { + response = "None of the tasks successfully added"; + } + } + else if (added.Count > 0 && failed.Count > 0) + { + response = $"Added: {String.Join(" | ", added)} | Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; + if (response.Length > characterLimit) + { + response = "Some tasks successful but some failed :p"; + } + } + + return response; + } + + private string BuildLogResponseMessage(List added, List<(string, string)> failed) + { + string response = "No tasks to add"; + if (added.Count > 0 && failed.Count == 0) + { + response = $"Added: {String.Join(" | ", added)}"; + if (response.Length > characterLimit) + { + response = "All the tasks have been added!"; + } + } + else if (added.Count == 0 && failed.Count == 1) + { + response = failed[0].Item2; // Single error, show the reason + } + else if (added.Count == 0 && failed.Count > 1) + { + response = $"Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; + if (response.Length > characterLimit) + { + response = "None of the tasks successfully added"; + } + } + else if (added.Count > 0 && failed.Count > 0) + { + response = $"Added: {String.Join(" | ", added)} | Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; + if (response.Length > characterLimit) + { + response = "Some tasks successful but some failed :p"; + } + } + + return response; + } + + // focus on existing task, or add a new task and focus on it + private Response<(int, string)> FocusOnTask(string rawInput) + { + // make sure there's no separators + bool containsSeparators = rawInput.IndexOfAny(separators) >= 0; + if (containsSeparators) + { + return new(false, default, "Cannot focus on multiple tasks"); + } + + List tasks = ListUserTasks(); + int IndexByName = tasks.FindIndex(t => t.Name.Equals(rawInput, StringComparison.OrdinalIgnoreCase)); + // existing task by name, new task, or index + if (int.TryParse(rawInput, out int n)) + { + n = n - 1; // true index + // IT'S A NUMBER + if (n < 0 || n >= tasks.Count) + { + return new(false, default, "Index out of range."); + } + else if (tasks[n].Completed) + { + // task already completed, cannot focus on it + return new(false, default, "Cannot focus on completed task."); + } + else + { + // unfocus on every single task + // then focus on that task + for (int i = 0; i < tasks.Count; i++) + { + tasks[i].Focused = false; + } + + tasks[n].Focused = true; + SaveIntoTasks(tasks); + Broadcast(new { mode = "focus", index = n }); + return new(true, (n, tasks[n].Name), null); + } + } + else if (IndexByName > -1) + { + // it's an existing task + n = IndexByName; + if (tasks[n].Completed) + { + // task already completed, cannot focus on it + return new(false, default, "Cannot focus on completed task."); + } + + for (int i = 0; i < tasks.Count; i++) + { + tasks[i].Focused = false; + } + + tasks[n].Focused = true; + SaveIntoTasks(tasks); + Broadcast(new { mode = "focus", index = n }); + return new(true, (n, tasks[n].Name), null); + } + else + { + // new task + var response = AddTask(rawInput, false, true); + if (response.Success) + { + Broadcast(new { mode = "focus", index = response.Data.Item1 }); + return new(true, (response.Data.Item1, response.Data.Item2), null); + } + else + { + return new(false, default, $"{response.ErrorMsg}"); + } + } + } + + // FOCUS COMMAND + // 1: focus on existing task by name (check if already focused) + // 2: focus on existing task by index (must be valid index that isn't already focused) + // 3: adding a new task by name + public bool FocusCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + // make sure there's no separators + var AddOrSelectResponse = FocusOnTask(rawInput); + if (!AddOrSelectResponse.Success) + { + Respond(AddOrSelectResponse.ErrorMsg); + } + else + { + Respond($"Current focused task: {AddOrSelectResponse.Data.Item1}. {AddOrSelectResponse.Data.Item2}"); + } + + return true; + } + + // return true index + private int GetFocusedTask() + { + List userTasks = ListUserTasks(); + var incompleteTasks = userTasks.Where(t => !t.Completed); + if (incompleteTasks.Count() == 1) + { + return userTasks.FindIndex(t => !t.Completed); + } + + return userTasks.FindIndex(t => t.Focused); + } + + // NEXT COMMAND + // get focused task -> mark it as complete -> focus on existing/new task + public bool NextCommand() + { + List userTasks = ListUserTasks(); + int focusedTaskIndex = GetFocusedTask(); + if (focusedTaskIndex == -1) + { + Respond("Can't use !next command, select a task to complete using !done and/or add another task"); + return false; + } + + // Focus on the task + CPH.TryGetArg("rawInput", out string rawInput); + var FocusOnTaskResponse = FocusOnTask(rawInput); + if (!FocusOnTaskResponse.Success) + { + Respond(FocusOnTaskResponse.ErrorMsg); + return false; + } + + int newTaskIndex = FocusOnTaskResponse.Data.Item1; + string taskString = FocusOnTaskResponse.Data.Item2; + // mark it as complete + string completedTaskName = userTasks[focusedTaskIndex].Name; + userTasks[focusedTaskIndex].Completed = true; + userTasks[focusedTaskIndex].Focused = false; + Broadcast(new { mode = "done", index = focusedTaskIndex }); + SaveIntoTasks(userTasks); + Respond($"Completed '{completedTaskName}'! Moving onto '({newTaskIndex + 1}) {taskString}'"); + return true; + } + + // EDIT COMMAND + public bool EditCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + // parse check input + var EditData = ParseEditInput(rawInput); + if (!EditData.Success) + { + Respond(EditData.ErrorMsg); + } + + int taskIndex = EditData.Data.Item1; + string newTask = EditData.Data.Item2; + var result = EditTask(taskIndex, newTask); + if (!result.Success) + { + Respond(result.ErrorMsg); + } + else + { + Respond($"Task '{result.Data.Item1}' has been edited to '{result.Data.Item2}'"); + } + + // edit task + return true; + } + + private Response<(string, string)> EditTask(int index, string newTask) + { + List userTasks = ListUserTasks(); + // task data doesn't exist + if (userTasks.Count == 0) + { + // Respond("404 Tasks not found"); + return new(false, default, "Error 404: Tasks not found"); + } + + // out of range + if (index > userTasks.Count || index < 0) + { + return new(false, default, "Error: Invalid task number"); + } + + // incomplete task already exists + bool taskAlreadyExists = userTasks.FindIndex(t => t.Name.Equals(newTask, StringComparison.OrdinalIgnoreCase)) > -1; + if (taskAlreadyExists) + { + return new(false, default, "Error: Task already exists"); + } + + // userTasks + string oldName = userTasks[index].Name; + userTasks[index].Name = newTask; + SaveIntoTasks(userTasks); + Broadcast(new { mode = "edit", index = index, task = newTask }); + return new(true, (oldName, newTask), null); + } + + // simple: !edit + // Response<(int, string)> + private Response<(int, string)> ParseEditInput(string rawInput) + { + bool validEditInput = true; + rawInput = rawInput.Trim(); + int focusedTaskIndex = GetFocusedTask(); + bool hasFocusedTask = focusedTaskIndex > -1; + string[] spaceSeparated = rawInput.Split(new[] { ' ' }, 2); + if (spaceSeparated.Length < 2) + { + validEditInput = false; + if (!hasFocusedTask) + { + return new Response<(int, string)>(false, default, "Error: Not enough arguments, try !edit "); + } + } + + string numberString = spaceSeparated[0]; + string newTask = spaceSeparated[1]; + if (!int.TryParse(numberString, out int index)) + { + validEditInput = false; + if (!hasFocusedTask) + { + return new Response<(int, string)>(false, default, "Error: Not a valid argument, try !edit "); + } + } + + if (validEditInput) + { + return new Response<(int, string)>(true, (index - 1, newTask), null); + } + else + { + return new Response<(int, string)>(true, (focusedTaskIndex, rawInput), null); + } + } + + // CHECK COMMAND + private List ListUserTasks(string? userKey = null) + { + List emptyList = new List(); + if (this.taskData == null || this.taskData.Count == 0) + { + return emptyList; // return empty task list + } + + // user's data doesn't exist + string key = userKey ?? GetKey(); + var userData = this.taskData[key]; + if (userData == null) + { + return emptyList; + } + + // 0 tasks + List tasks = userData.tasks; + if (tasks.Count == 0) + { + return emptyList; + } + + return this.taskData[key].tasks; + } + + public bool CheckCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + rawInput = rawInput.Trim(); + string? key = null; + bool someoneElse = false; + if (!String.IsNullOrWhiteSpace(rawInput)) + { + key = GetKey(rawInput); + if (key == "") + { + Respond("User not found"); + return false; + } + else + { + someoneElse = true; + } + } + + List userTasks = ListUserTasks(key); + // task data doesn't exist + if (userTasks.Count == 0) + { + Respond("404 Tasks not found"); + return false; + } + + // JOIN THE TASKS INTO ONE MESSAGE + // edit however you like + string message = String.Join(" | ", userTasks.Select((t, index) => $"{index + 1}. {(t.Focused ? "(ongoing) " : "")}{t.Name}")); + if (someoneElse) + { + string theirUser = GetUsername(key); + message = $"{theirUser}'s tasks: {message}"; + } + Respond(message); + return true; + } + + public bool ListCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + rawInput = rawInput.Trim(); + string separator = "; "; + string validSeparators = ";,|"; + if (rawInput.Length == 1 && validSeparators.Contains(rawInput)) + { + separator = $"{rawInput} "; + } + + List userTasks = ListUserTasks(); + string message = String.Join(separator, userTasks.Where((t, index) => !t.Completed).Select(task => task.Name)); + Respond(message); + return true; + } + + // Helper method to get task index by number or name + private int GetTaskIndex(List tasks, string input) + { + if (int.TryParse(input, out int n)) + { + int index = n - 1; // Convert 1-based to 0-based + return (index >= 0 && index < tasks.Count) ? index : -1; + } + + return tasks.FindIndex(t => t.Name.Equals(input, StringComparison.OrdinalIgnoreCase)); + } + + // --- REMOVE TASK --- + private List ParseTasksInput(string input) + { + input = input.Trim(); + var tasksToRemove = new List(); + bool IsSpaceSeparatedInts = Regex.IsMatch(input, @"^\d+(\s+\d+)*$"); + if (IsSpaceSeparatedInts) + { + return input.Split(' ').ToList(); + } + + var splittedInput = input.Split(separators, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()).ToList(); + if (splittedInput.Count == 0) + { + // get focused task + int focusedTaskIndex = GetFocusedTask() + 1; + // return false index + return new List + { + focusedTaskIndex.ToString() + }; + } + else + { + return splittedInput; + } + } + + private string BuildRemoveMessage(List tasksRemoved, List tasksFailedToRemove) + { + // Build response + string removedString = String.Join(", ", tasksRemoved); + if (tasksFailedToRemove.Count == 0) + { + return $"Removed task(s)!"; + } + else + { + string failedString = String.Join(", ", tasksFailedToRemove); + return $"Failed to remove: {failedString}"; + } + } + + // remove user(s) if they don't have tasks + private void Cleanup(bool userOnly = false) + { + if (userOnly) + { + List userTasks = ListUserTasks(); + if (userTasks.Count == 0) + { + string userKey = GetKey(); + this.taskData.Remove(userKey); + } + } + else + { + List KeysToRemove = new List(); + foreach (var item in this.taskData) + { + if (item.Value.tasks.Count == 0) + { + KeysToRemove.Add(item.Key); + } + } + + foreach (string key in KeysToRemove) + { + this.taskData.Remove(key); + } + } + + SaveTasks(); + } + + public bool RemoveCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + List userTasks = ListUserTasks(); + if (userTasks.Count == 0) + { + Respond("Error 404: Tasks not found"); + return false; + } + + List tasksToBeRemoved = ParseTasksInput(rawInput); + if (tasksToBeRemoved.Count == 0) + { + Respond("Error: Invalid input"); + return false; + } + + List tasksRemoved = new List(); + List tasksFailedToRemove = new List(); + List taskIndices = new List(); + // Gather indices of tasks to be removed + foreach (string task in tasksToBeRemoved) + { + int index = GetTaskIndex(userTasks, task); + if (index > -1 && !taskIndices.Contains(index)) + { + taskIndices.Add(index); + tasksRemoved.Add(userTasks[index].Name); // Track what we're removing + } + else + { + tasksFailedToRemove.Add(task); + } + } + + // Nothing valid to remove + if (taskIndices.Count == 0) + { + string failedString = String.Join(", ", tasksFailedToRemove); + Respond($"Failed to remove task(s): {failedString}"); + return false; + } + + // Remove from highest index to lowest to preserve indices + foreach (int i in taskIndices.OrderByDescending(n => n)) + { + userTasks.RemoveAt(i); + Broadcast(new { mode = "remove", index = i }); + } + + // Save data + SaveIntoTasks(userTasks); + Cleanup(true); + Respond(BuildRemoveMessage(tasksRemoved, tasksFailedToRemove)); + return true; + } + + // admin delete + // !adel @user + public bool AdminDelete() + { + CPH.TryGetArg("rawInput", out string rawInput); + string[] spaceSeparated = rawInput.Split(new[] { ' ' }, 2); + if (spaceSeparated.Count() == 0) + { + return false; + } + + string user = spaceSeparated[0]; + string key = GetKey(user); + if (key == "") + { + Respond("Error: Unable to find user with that username on the task list"); + return false; + } + + // fuck it, just remove all + this.taskData.Remove(key); + SaveTasks(); + Respond("All of the user's tasks have been deleted"); + Broadcast(new { mode = "admindelete", id = key }); + return true; + } + + // done command + private string BuildCompletedMessage(List tasksCompleted, List tasksFailedToComplete) + { + // Build response + // string completedString = String.Join(", ", tasksCompleted); + if (tasksFailedToComplete.Count == 0 && tasksCompleted.Count == 1) + { + return "Task completed!"; + } + else if (tasksFailedToComplete.Count == 0) + { + return "Completed all task(s) specified!"; + } + else + { + string failedString = String.Join(", ", tasksFailedToComplete); + return $"Failed to complete: {failedString}"; + } + } + + public bool DoneCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + List userTasks = ListUserTasks(); + if (userTasks.Count == 0) + { + Respond("Error 404: Tasks not found"); + return false; + } + + List tasksToBeCompleted = ParseTasksInput(rawInput); + if (tasksToBeCompleted.Count == 0) + { + Respond("Error: Invalid input"); + return false; + } + + List tasksCompleted = new List(); + List tasksFailedToComplete = new List(); + List taskIndices = new List(); + // Gather indices of tasks to be removed + foreach (string task in tasksToBeCompleted) + { + int index = GetTaskIndex(userTasks, task); + if (index > -1 && !taskIndices.Contains(index) && !userTasks[index].Completed) + { + taskIndices.Add(index); + tasksCompleted.Add(userTasks[index].Name); // Track what we're removing + } + else + { + tasksFailedToComplete.Add(task); + } + } + + // Nothing valid to complete + if (taskIndices.Count == 0) + { + string failedString = String.Join(", ", tasksFailedToComplete); + Respond($"Failed to complete task(s): {failedString}"); + return false; + } + + // Mark all as complete + foreach (int i in taskIndices) + { + userTasks[i].Completed = true; + userTasks[i].Focused = false; + Broadcast(new { mode = "done", index = i }); + } + + // Save data + SaveIntoTasks(userTasks); + Respond(BuildCompletedMessage(tasksCompleted, tasksFailedToComplete)); + return true; + } + + // unfocus + private void Unfocus() + { + List tasks = ListUserTasks(); + for (int i = 0; i < tasks.Count; i++) + { + tasks[i].Focused = false; + } + + SaveIntoTasks(tasks); + } + + public bool UnfocusCommand() + { + Unfocus(); + Respond("Task have been unfocused!"); + Broadcast(new { mode = "unfocus" }); + return true; + } + + // undone + public bool UndoneCommand() + { + CPH.TryGetArg("rawInput", out string rawInput); + List userTasks = ListUserTasks(); + if (userTasks.Count == 0) + { + Respond("Error 404: Tasks not found"); + return false; + } + + List tasksToBeCompleted = ParseUndoneInput(rawInput); + if (tasksToBeCompleted.Count == 0) + { + Respond("Error: Invalid input"); + return false; + } + + List tasksCompleted = new List(); + List tasksFailedToComplete = new List(); + List taskIndices = new List(); + // Gather indices of tasks to be removed + foreach (string task in tasksToBeCompleted) + { + int index = GetTaskIndex(userTasks, task); + if (index > -1 && !taskIndices.Contains(index) && userTasks[index].Completed) + { + taskIndices.Add(index); + tasksCompleted.Add(userTasks[index].Name); // Track what we're removing + } + else + { + tasksFailedToComplete.Add(task); + } + } + + // Nothing valid to complete + if (taskIndices.Count == 0) + { + string failedString = String.Join(", ", tasksFailedToComplete); + Respond($"Failed to un-done task(s): {failedString}"); + return false; + } + + // Mark all as complete + foreach (int i in taskIndices) + { + userTasks[i].Completed = false; + userTasks[i].Focused = false; + Broadcast(new { mode = "undone", index = i }); + } + + // Save data + SaveIntoTasks(userTasks); + Respond(BuildUndoneMessage(tasksCompleted, tasksFailedToComplete)); + return true; + } + + private List ParseUndoneInput(string input) + { + input = input.Trim(); + var tasksToRemove = new List(); + bool IsSpaceSeparatedInts = Regex.IsMatch(input, @"^\d+(\s+\d+)*$"); + if (IsSpaceSeparatedInts) + { + return input.Split(' ').ToList(); + } + + var splittedInput = input.Split(separators, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()).ToList(); + if (splittedInput.Count == 0) + { + // get the only completed task + List userTasks = ListUserTasks(); + int soloCompletedTaskIndex = -1; + var completedTasks = userTasks.Where(t => t.Completed); + if (completedTasks.Count() == 1) + { + soloCompletedTaskIndex = userTasks.FindIndex(t => t.Completed) + 1; + return new List + { + soloCompletedTaskIndex.ToString() + }; + } + } + else + { + return splittedInput; + } + + return new() + { + }; + } + + private string BuildUndoneMessage(List tasksCompleted, List tasksFailedToComplete) + { + // Build response + // string completedString = String.Join(", ", tasksCompleted); + if (tasksFailedToComplete.Count == 0 && tasksCompleted.Count == 1) + { + return "Task marked as incomplete!"; + } + else if (tasksFailedToComplete.Count == 0) + { + return "Task(s) marked as incomplete!"; + } + else + { + string failedString = String.Join(", ", tasksFailedToComplete); + return $"Failed to parse: {failedString}"; + } + } + + // CLEAR TASKS + public bool ClearAllCommand() + { + // clear all TASKS only + foreach (var item in this.taskData) + { + this.taskData[item.Key].tasks = new() + { + }; + } + + Cleanup(false); + SaveTasks(); + Broadcast(new { mode = "clearall" }); + Respond("All tasks have been cleared!"); + return true; + } + + public bool ClearMyDoneCommand() + { + // clear all of the user's completed tasks only + string key = GetKey(); + this.taskData[key].tasks = this.taskData[key].tasks.Where(t => !t.Completed).ToList(); + Cleanup(false); + SaveTasks(); + Broadcast(new { mode = "clearmydone" }); + Respond("All of your completed tasks have been cleared!"); + return true; + } + + public bool ClearDoneCommand() + { + // clear all COMPLETED TASKS only + foreach (var item in this.taskData) + { + this.taskData[item.Key].tasks = this.taskData[item.Key].tasks.Where(t => !t.Completed).ToList(); + } + + Cleanup(false); + SaveTasks(); + Broadcast(new { mode = "cleardone" }); + Respond("All completed tasks have been cleared!"); + return true; + } + + public bool ClearNotStreamerCommand() + { + var streamersUsernames = GetStreamerUsernames(); + // clear all TASKS only if not + this.taskData = this.taskData.Where(kvp => streamersUsernames.Any(s => string.Equals(s, kvp.Value.username, StringComparison.OrdinalIgnoreCase))).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); + Cleanup(false); + SaveTasks(); + Broadcast(new { mode = "clearns" }); + Respond("All completed tasks have been cleared!"); + return true; + } +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..fb2aab5 --- /dev/null +++ b/README.md @@ -0,0 +1,90 @@ +# Rython Task Bot v2 + +![C#](https://img.shields.io/badge/c%23-%23239120.svg?style=for-the-badge&logo=csharp&logoColor=white) +![CSS](https://img.shields.io/badge/Streamer.Bot-%234285F4.svg?style=for-the-badge&logoColor=white) +![Twitch](https://img.shields.io/badge/twitch-8957E5?style=for-the-badge&logo=twitch&logoColor=white) +![YouTube](https://img.shields.io/badge/youtube-FF0000?style=for-the-badge&logo=youtube&logoColor=white) + +Task Bot for Co-working streamers on Twitch & YouTube. + +## Why this Task Bot? + +- Browser Source is optional + - You only need Streamer.Bot running to have it working with Twitch chat +- Compatible with Twitch and YouTube; possibly extending to Kick and Trovo +- Task data is accessible via Streamer.Bot global variable +- Commands' permissions are easily configurable: + - Mod (and Streamer) only + - VIP and above + - Subscribers and above + - etc. +- Easy customizable with other Streamer.Bot actions + +## Setup Instructions + +1. Install and setup [Streamer.Bot](https://streamer.bot/) + - [Nutty's Reference Video](https://youtu.be/gfGy1gRH5ik?t=146) + +2. Open Streamer.Bot and click on Import + + > ![Import Button](./images/import-button.png) + +3. Import the string from [RythonTaskBot.sb](./RythonTaskBot.sb) + + - Copy paste the string into the `Import` box + + OR + + - Drag the file into the `Import` box + + > ![Imported](./images/imported.png) + +4. Click on the `Import` button + +5. You may need to go to the Commands tab and enable the commands. + +## Usage + +### Add task: + +- `!task ` + + Aliases: + - `!a` + - `!add` + - `!taskadd` + +### Edit task: + +- `!edit ` + + Aliases: + - `!e` + - `!taskedit` + +### Complete task: + +- `!done ` +- `!done ` + + Aliases: + - `!f` + - `!finish` + - `!complete` + +### Remove task: + +- `!remove ` + +### Admin delete user's tasks: + +- `!adel @username` + + Aliases: + - `!admindelete` + +(Work in progress) + +## Credits + +- [RythonDev](https://twitch.tv/RythonDev) diff --git a/RythonTaskBot.sb b/RythonTaskBot.sb new file mode 100644 index 0000000..8d80957 --- /dev/null +++ b/RythonTaskBot.sb @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/images/import-button.png b/images/import-button.png new file mode 100644 index 0000000000000000000000000000000000000000..b6d5b911498a91a3e1759b542b9d526503989875 GIT binary patch literal 22232 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