ShopSolution-backend/Webshop.Application/Services/Admin/AdminCategoryService.cs

// src/Webshop.Application/Services/Admin/AdminCategoryService.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Webshop.Application.DTOs.Categorys;
using Webshop.Domain.Entities;
using Webshop.Domain.Interfaces;

namespace Webshop.Application.Services.Admin
{
    public class AdminCategoryService : IAdminCategoryService
    {
        private readonly ICategoryRepository _categoryRepository;

        public AdminCategoryService(ICategoryRepository categoryRepository)
        {
            _categoryRepository = categoryRepository;
        }

        public async Task<IEnumerable<CategoryDto>> GetAllAsync()
        {
            var categories = await _categoryRepository.GetAllAsync();
            return categories.Select(c => new CategoryDto
            {
                Id = c.Id,
                Name = c.Name,
                Slug = c.Slug,
                Description = c.Description,
                ParentCategoryId = c.ParentCategoryId,
                ImageUrl = c.ImageUrl,
                IsActive = c.IsActive,
                DisplayOrder = c.DisplayOrder
            }).ToList();
        }

        public async Task<CategoryDto?> GetByIdAsync(Guid id)
        {
            var category = await _categoryRepository.GetByIdAsync(id);
            if (category == null) return null;

            return new CategoryDto
            {
                Id = category.Id,
                Name = category.Name,
                Slug = category.Slug,
                Description = category.Description,
                ParentCategoryId = category.ParentCategoryId,
                ImageUrl = category.ImageUrl,
                IsActive = category.IsActive,
                DisplayOrder = category.DisplayOrder
            };
        }

        public async Task<(CategoryDto? CreatedCategory, string? ErrorMessage)> CreateAsync(CreateCategoryDto categoryDto)
        {
            var existingCategory = await _categoryRepository.GetBySlugAsync(categoryDto.Slug);
            if (existingCategory != null)
            {
                return (null, "Eine Kategorie mit diesem Slug existiert bereits.");
            }

            var category = new Category
            {
                Id = Guid.NewGuid(),
                Name = categoryDto.Name,
                Slug = categoryDto.Slug,
                Description = categoryDto.Description,
                ParentCategoryId = categoryDto.ParentCategoryId,
                ImageUrl = categoryDto.ImageUrl,
                IsActive = categoryDto.IsActive,
                DisplayOrder = categoryDto.DisplayOrder,
                CreatedDate = DateTimeOffset.UtcNow
            };

            await _categoryRepository.AddAsync(category);

            var createdDto = new CategoryDto
            {
                Id = category.Id,
                Name = category.Name,
                Slug = category.Slug,
                Description = category.Description,
                ParentCategoryId = category.ParentCategoryId,
                ImageUrl = category.ImageUrl,
                IsActive = category.IsActive,
                DisplayOrder = category.DisplayOrder
            };

            return (createdDto, null);
        }

        public async Task<(bool Success, string? ErrorMessage)> UpdateAsync(Guid id, CreateCategoryDto categoryDto)
        {
            var existingCategory = await _categoryRepository.GetByIdAsync(id);
            if (existingCategory == null)
            {
                return (false, "Kategorie nicht gefunden.");
            }

            var categoryWithSameSlug = await _categoryRepository.GetBySlugAsync(categoryDto.Slug);
            if (categoryWithSameSlug != null && categoryWithSameSlug.Id != id)
            {
                return (false, "Eine andere Kategorie mit diesem Slug existiert bereits.");
            }

            existingCategory.Name = categoryDto.Name;
            existingCategory.Slug = categoryDto.Slug;
            existingCategory.Description = categoryDto.Description;
            existingCategory.ParentCategoryId = categoryDto.ParentCategoryId;
            existingCategory.ImageUrl = categoryDto.ImageUrl;
            existingCategory.IsActive = categoryDto.IsActive;
            existingCategory.DisplayOrder = categoryDto.DisplayOrder;
            existingCategory.LastModifiedDate = DateTimeOffset.UtcNow;

            await _categoryRepository.UpdateAsync(existingCategory);
            return (true, null);
        }

        public async Task<bool> DeleteAsync(Guid id)
        {
            var category = await _categoryRepository.GetByIdAsync(id);
            if (category == null) return false;

            await _categoryRepository.DeleteAsync(id);
            return true;
        }
    }
}