Controllers/TasksMvcController.cs - main - NikitaMalyshko/TaskManager

Controllers/TasksMvcController.cs
246 строк7 KB
Nikita Malyshko
Initial commit - TaskFlow - менеджер задач с Web API и MVC интерфейсом
25 апр 2026, 02:30
25 апр 2026, 02:304ff0625
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.EntityFrameworkCore;
using TaskManager.Data;
using TaskManager.Models;

namespace TaskManager.Controllers;

public class TasksMvcController : Controller
{
    private readonly AppDbContext _context;

    public TasksMvcController(AppDbContext context)
    {
        _context = context;
    }

    // GET: TasksMvc
    // GET: TasksMvc
    public async Task<IActionResult> Index(string searchString, string statusFilter, int? categoryFilter)
    {
        ViewBag.SearchString = searchString;
        ViewBag.StatusFilter = statusFilter;
        ViewBag.CategoryFilter = categoryFilter;

        var categories = await _context.Categories.ToListAsync();
        ViewBag.Categories = categories;

        // Базовый запрос
        var tasksQuery = _context.Tasks.Include(t => t.Category).AsQueryable();

        // Поиск по названию
        if (!string.IsNullOrEmpty(searchString))
        {
            tasksQuery = tasksQuery.Where(t => t.Title.Contains(searchString));
        }

        // Фильтр по статусу
        if (!string.IsNullOrEmpty(statusFilter))
        {
            bool isCompleted = statusFilter == "completed";
            tasksQuery = tasksQuery.Where(t => t.IsCompleted == isCompleted);
        }

        // Фильтр по категории
        if (categoryFilter.HasValue && categoryFilter.Value > 0)
        {
            tasksQuery = tasksQuery.Where(t => t.CategoryId == categoryFilter);
        }

        var tasks = await tasksQuery
            .OrderBy(t => t.IsCompleted)
            .ThenBy(t => t.Id)
            .ToListAsync();

        // Считаем статистику
        var stats = new TaskStatisticsViewModel
        {
            TotalTasks = await _context.Tasks.CountAsync(),
            CompletedTasks = await _context.Tasks.CountAsync(t => t.IsCompleted),
            PendingTasks = await _context.Tasks.CountAsync(t => !t.IsCompleted),
            CategoriesStats = await _context.Categories
                .Select(c => new CategoryStat
                {
                    CategoryName = c.Name,
                    TaskCount = c.Tasks.Count(),
                    CompletedCount = c.Tasks.Count(t => t.IsCompleted)
                })
                .ToListAsync()
        };

        ViewBag.Stats = stats;

        return View(tasks);
    }

    // GET: TasksMvc/Create
    public async Task<IActionResult> Create()
    {
        await LoadCategoriesDropdown();
        return View();
    }

    // POST: TasksMvc/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(TaskItem task, string? categoryName)
    {
        // ЖЁСТКОЕ ЛОГИРОВАНИЕ В КОНСОЛЬ
        System.Console.WriteLine($"[DEBUG] Title из формы: '{task.Title}'");
        System.Console.WriteLine($"[DEBUG] CategoryName из формы: '{categoryName}'");

        // Пропускаем валидацию ModelState
        ModelState.Clear();

        // Создаём задачу ВРУЧНУЮ
        var newTask = new TaskItem
        {
            Title = task.Title ?? "Без названия",
            IsCompleted = task.IsCompleted
        };

        if (!string.IsNullOrWhiteSpace(categoryName))
        {
            var category = await _context.Categories
                .FirstOrDefaultAsync(c => c.Name == categoryName.Trim());

            if (category == null)
            {
                category = new Category { Name = categoryName.Trim() };
                _context.Categories.Add(category);
                await _context.SaveChangesAsync();
            }

            newTask.CategoryId = category.Id;
        }

        _context.Tasks.Add(newTask);
        await _context.SaveChangesAsync();

        System.Console.WriteLine($"[DEBUG] Сохранено. Title: '{newTask.Title}', Id: {newTask.Id}");

        return RedirectToAction(nameof(Index));
    }

    // GET: TasksMvc/Edit/5
    public async Task<IActionResult> Edit(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var task = await _context.Tasks.FindAsync(id);
        if (task == null)
        {
            return NotFound();
        }

        await LoadCategoriesDropdown(task.CategoryId);
        return View(task);
    }

    // POST: TasksMvc/Edit/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Edit(int id, TaskItem task, string? categoryName)
    {
        if (id != task.Id) return NotFound();

        if (ModelState.IsValid)
        {
            try
            {
                if (!string.IsNullOrWhiteSpace(categoryName))
                {
                    var category = await _context.Categories
                        .FirstOrDefaultAsync(c => c.Name == categoryName.Trim());

                    if (category == null)
                    {
                        category = new Category { Name = categoryName.Trim() };
                        _context.Categories.Add(category);
                        await _context.SaveChangesAsync();
                    }

                    task.CategoryId = category.Id;
                }
                else
                {
                    task.CategoryId = null;
                }

                _context.Update(task);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!await TaskExists(id)) return NotFound();
                throw;
            }
            return RedirectToAction(nameof(Index));
        }
        return View(task);
    }

    // GET: TasksMvc/Delete/5
    public async Task<IActionResult> Delete(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var task = await _context.Tasks
            .Include(t => t.Category)
            .FirstOrDefaultAsync(m => m.Id == id);

        if (task == null)
        {
            return NotFound();
        }

        return View(task);
    }

    // POST: TasksMvc/Delete/5
    [HttpPost, ActionName("Delete")]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> DeleteConfirmed(int id)
    {
        var task = await _context.Tasks.FindAsync(id);
        if (task != null)
        {
            _context.Tasks.Remove(task);
            await _context.SaveChangesAsync();
        }

        return RedirectToAction(nameof(Index));
    }

    // POST: TasksMvc/Toggle/5
    [HttpPost]
    // [ValidateAntiForgeryToken]
    public async Task<IActionResult> Toggle(int id)
    {
        var task = await _context.Tasks.FindAsync(id);
        if (task != null)
        {
            task.IsCompleted = !task.IsCompleted;
            await _context.SaveChangesAsync();
        }
        return RedirectToAction(nameof(Index));
    }

    private async Task<bool> TaskExists(int id)
    {
        return await _context.Tasks.AnyAsync(e => e.Id == id);
    }

    private async Task LoadCategoriesDropdown(int? selectedCategoryId = null)
    {
        var categories = await _context.Categories.ToListAsync();
        ViewBag.Categories = new SelectList(categories, "Id", "Name", selectedCategoryId);
    }
}