📋Move functionality from Task to TaskHandler

[java3east]

📋 Task

The Task class currently mixes attributes with a wide range of functionality. To simplify the flow of operations and reduce unnecessary layering, most task-related logic should be moved into TaskHandler. The Task class will remain primarily a data holder, but simple, self-contained operations will stay within it.

Rationale

• Operations on tasks currently move through many layers, making the flow harder to follow.
  Moving complex logic into TaskHandler will shorten this path and centralize control.
• Keeping only simple operations in Task preserves convenience while avoiding bloat.

Proposed Changes

• Identify and move complex functionality from Task into TaskHandler.
• Keep only lightweight, self-contained operations within Task.

No duplicate issue

• I confirm that this issue is not a duplicate

Code of Conduct

• I agree to follow this project's Code of Conduct

[IamPekka058]

@CodeRabbit plan

[coderabbitai]

Coding Plan

Summary

• Move GitHub API call logic (issues.create, issues.edit, issues.deleteIssue) from Task's remote methods into private methods within TaskHandler
• Update TaskHandler's public methods (saveTask, deleteTask, updateIssueState) to use these new internal methods instead of delegating to Task
• Remove the now-unused remote methods from Task, leaving it as a clean data holder with only copy(), replace(), and factory constructors
• No ViewModel changes are required since they already use TaskHandler exclusively for remote operations

Implementation Steps

Phase 1: Centralize Remote Operations in TaskHandler

This phase adds GitHub API call logic directly to TaskHandler, replacing the current delegation pattern where TaskHandler calls Task's remote methods.

Task 1: Add Private Remote Operation Methods to TaskHandler

Add private methods in TaskHandler that perform the actual GitHub API calls, mirroring the logic currently in Task.

• Add _createIssue(Task task) method in lib/core/task_handler.dart that calls GithubModel.github.issues.create() with an IssueRequest built from the task's fields, returning a new Task via Task.fromIssue()
• Add _updateIssue(Task task) method that calls GithubModel.github.issues.edit() using the task's slug and issueNumber, returning the updated Task
• Add _deleteIssue(Task task) method that calls GithubModel.github.issues.deleteIssue() using the task's slug and issueNumber
• These methods will use the same API patterns currently in Task but centralized in TaskHandler

Task 2: Update saveTask() to Use Internal Methods

Modify the existing saveTask() method in TaskHandler to directly perform remote operations instead of delegating to task.saveRemote().

• Update saveTask() in lib/core/task_handler.dart to check if task has an issueNumber
• If no issueNumber (new task): call the new _createIssue() method
• If issueNumber exists (existing task): call the new _updateIssue() method
• Keep the existing logic for adding to _tasks list, duplicate checking, and notifyListeners()

Task 3: Update deleteTask() to Use Internal Methods

Modify the existing deleteTask() method in TaskHandler to directly perform remote operations.

• Update deleteTask() in lib/core/task_handler.dart to call _deleteIssue() instead of task.deleteRemote()
• Add a guard clause to handle tasks without an issueNumber (same as current Task.deleteRemote behavior)
• Keep existing logic for removing from _tasks list and notifying listeners

Task 4: Update updateIssueState() to Use Internal Methods

Modify the existing updateIssueState() method to use the new internal update method.

• Update updateIssueState() in lib/core/task_handler.dart to mutate task state fields as currently done
• Replace the ..saveRemote() cascade call with a proper call to _updateIssue()
• Consider awaiting the remote call to fix the existing fire-and-forget pattern (this naturally addresses a latent bug during the refactor)

🤖 Prompt for AI agents

This phase centralizes all GitHub API remote operations into TaskHandler
(`lib/core/task_handler.dart`), replacing the delegation pattern where
TaskHandler called Task's remote methods.

**Add three new private methods to TaskHandler:**
- `_createIssue(Task task)`: Calls `GithubModel.github.issues.create()` with an
`IssueRequest` built from the task's fields; returns a new `Task` via
`Task.fromIssue()`
- `_updateIssue(Task task)`: Calls `GithubModel.github.issues.edit()` using the
task's `slug` and `issueNumber`; returns the updated `Task`
- `_deleteIssue(Task task)`: Calls `GithubModel.github.issues.deleteIssue()`
using the task's `slug` and `issueNumber`
- Mirror the exact API patterns currently used in `Task`'s remote methods

**Update `saveTask()`:**
- Check if the task has an `issueNumber`
- If no `issueNumber` (new task): call `_createIssue()`
- If `issueNumber` exists (existing task): call `_updateIssue()`
- Preserve existing logic for adding to `_tasks` list, duplicate checking, and
`notifyListeners()`
- Remove the delegation call to `task.saveRemote()`

**Update `deleteTask()`:**
- Replace the call to `task.deleteRemote()` with a call to `_deleteIssue()`
- Add a guard clause to skip the remote call if the task has no `issueNumber`
(matching current Task.deleteRemote behavior)
- Preserve existing logic for removing from `_tasks` list and notifying
listeners

**Update `updateIssueState()`:**
- Retain existing mutation of task state fields
- Replace the `..saveRemote()` cascade call with a direct call to
`_updateIssue()`
- Await the remote call to fix the existing fire-and-forget pattern

Phase 2: Simplify Task Class to Data Holder

This phase removes the remote operation methods from Task, leaving it as a clean data model with only simple, self-contained operations.

Task 1: Remove Remote Methods from Task

Clean up the Task class by removing methods that are now handled by TaskHandler.

• Remove saveRemote() method from lib/core/models/task.dart
• Remove _createRemote() private method
• Remove _updateRemote() private method
• Remove deleteRemote() method
• Verify that GithubModel import can be removed from task.dart if no longer needed

Task 2: Verify Retained Task Functionality

Ensure the Task class retains all necessary data-holder capabilities and simple operations.

• Confirm copy() method remains for creating defensive copies (used by TaskEditViewModel)
• Confirm replace(Task) method remains for in-place updates (used by TaskDetailsViewModel)
• Confirm Task.fromIssue() factory constructor remains for mapping GitHub Issue responses to Task objects
• Confirm Task.createEmpty() factory constructor remains for creating new tasks
• Confirm all data fields (title, description, labels, state, slug, issueNumber, timestamps) remain accessible with appropriate getters/setters

🤖 Prompt for AI agents

This phase cleans up `lib/core/models/task.dart` by removing all remote
operation methods, leaving Task as a pure data holder.

**Remove the following from `lib/core/models/task.dart`:**
- `saveRemote()` public method
- `_createRemote()` private method
- `_updateRemote()` private method
- `deleteRemote()` public method
- Remove the `GithubModel` import if it is no longer referenced anywhere in the
file

**Verify the following are retained in `lib/core/models/task.dart`:**
- `copy()` method (used by TaskEditViewModel for defensive copies)
- `replace(Task)` method (used by TaskDetailsViewModel for in-place updates)
- `Task.fromIssue()` factory constructor (used to map GitHub Issue API responses
to Task objects)
- `Task.createEmpty()` factory constructor (used for creating new tasks)
- All data fields: `title`, `description`, `labels`, `state`, `slug`,
`issueNumber`, `timestamps`, along with their getters/setters

Research

The project is a Flutter application that manages tasks backed by GitHub Issues. The Task class (lib/core/models/task.dart) currently serves dual purposes: holding task data (title, description, labels, state, etc.) and performing remote GitHub API operations via the github_flutter package. TaskHandler (lib/core/task_handler.dart) is a singleton ChangeNotifier that manages the in-memory task list and coordinates operations, but currently delegates remote calls to Task methods. ViewModels in lib/ui/ already use TaskHandler for all remote operations, so they won't require changes. The GitHub API client is obtained via GithubModel.github.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

This phase centralizes all GitHub API remote operations into TaskHandler
(`lib/core/task_handler.dart`), replacing the delegation pattern where
TaskHandler called Task's remote methods.

**Add three new private methods to TaskHandler:**
- `_createIssue(Task task)`: Calls `GithubModel.github.issues.create()` with an
`IssueRequest` built from the task's fields; returns a new `Task` via
`Task.fromIssue()`
- `_updateIssue(Task task)`: Calls `GithubModel.github.issues.edit()` using the
task's `slug` and `issueNumber`; returns the updated `Task`
- `_deleteIssue(Task task)`: Calls `GithubModel.github.issues.deleteIssue()`
using the task's `slug` and `issueNumber`
- Mirror the exact API patterns currently used in `Task`'s remote methods

**Update `saveTask()`:**
- Check if the task has an `issueNumber`
- If no `issueNumber` (new task): call `_createIssue()`
- If `issueNumber` exists (existing task): call `_updateIssue()`
- Preserve existing logic for adding to `_tasks` list, duplicate checking, and
`notifyListeners()`
- Remove the delegation call to `task.saveRemote()`

**Update `deleteTask()`:**
- Replace the call to `task.deleteRemote()` with a call to `_deleteIssue()`
- Add a guard clause to skip the remote call if the task has no `issueNumber`
(matching current Task.deleteRemote behavior)
- Preserve existing logic for removing from `_tasks` list and notifying
listeners

**Update `updateIssueState()`:**
- Retain existing mutation of task state fields
- Replace the `..saveRemote()` cascade call with a direct call to
`_updateIssue()`
- Await the remote call to fix the existing fire-and-forget pattern
===============================================================================

Task: 2

This phase cleans up `lib/core/models/task.dart` by removing all remote
operation methods, leaving Task as a pure data holder.

**Remove the following from `lib/core/models/task.dart`:**
- `saveRemote()` public method
- `_createRemote()` private method
- `_updateRemote()` private method
- `deleteRemote()` public method
- Remove the `GithubModel` import if it is no longer referenced anywhere in the
file

**Verify the following are retained in `lib/core/models/task.dart`:**
- `copy()` method (used by TaskEditViewModel for defensive copies)
- `replace(Task)` method (used by TaskDetailsViewModel for in-place updates)
- `Task.fromIssue()` factory constructor (used to map GitHub Issue API responses
to Task objects)
- `Task.createEmpty()` factory constructor (used for creating new tasks)
- All data fields: `title`, `description`, `labels`, `state`, `slug`,
`issueNumber`, `timestamps`, along with their getters/setters

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!