erp-platform/api/src/Kurs.Platform.Application/Public/PublicAppService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Kurs.Platform.Entities;
using Kurs.Platform.Services;
using Volo.Abp.Domain.Repositories;
using System.Text;
using Kurs.Platform.Data.Seeds;
using Kurs.Sender.Mail;
using Volo.Abp.Settings;
using Kurs.Platform.Demos;
using Kurs.Platform.Blog;
using Volo.Abp.Domain.Entities;
using System.Linq;
using Volo.Abp.Application.Dtos;
using Kurs.Platform.Orders;
using System.Text.Json;
using Kurs.Platform.Abouts;
using Kurs.Platform.Contacts;

namespace Kurs.Platform.Public;

public class PublicAppService : PlatformAppService
{
    private readonly IRepository<Service, Guid> _serviceRepository;
    private readonly ISettingProvider _settingProvider;
    private readonly IKursEmailSender _emailSender;
    private readonly IRepository<Demo, Guid> _demoRepository;
    private readonly IRepository<BlogPost, Guid> _postRepository;
    private readonly IRepository<BlogCategory, Guid> _categoryRepository;
    private readonly IRepository<Product, Guid> _productRepository;
    private readonly IRepository<PaymentMethod, string> _paymentMethodRepository;
    private readonly IRepository<InstallmentOption> _installmentOptionRepository;
    private readonly IRepository<Order, Guid> _orderRepository;
    private readonly IRepository<About, Guid> _aboutRepository;
    private readonly IRepository<Contact, Guid> _contactRepository;

    public PublicAppService(
        IRepository<Service, Guid> serviceRepository,
        ISettingProvider settingProvider,
        IKursEmailSender emailSender,
        IRepository<Demo, Guid> demoRepository,
        IRepository<BlogPost, Guid> postRepository,
        IRepository<BlogCategory, Guid> categoryRepository,
        IRepository<Product, Guid> productRepository,
        IRepository<PaymentMethod, string> paymentMethodRepository,
        IRepository<InstallmentOption> installmentOptionRepository,
        IRepository<Order, Guid> orderRepository,
        IRepository<About, Guid> aboutRepository,
        IRepository<Contact, Guid> contactRepository
        )
    {
        _serviceRepository = serviceRepository;
        _settingProvider = settingProvider;
        _emailSender = emailSender;
        _demoRepository = demoRepository;
        _postRepository = postRepository;
        _categoryRepository = categoryRepository;
        _productRepository = productRepository;
        _paymentMethodRepository = paymentMethodRepository;
        _installmentOptionRepository = installmentOptionRepository;
        _orderRepository = orderRepository;
        _aboutRepository = aboutRepository;
        _contactRepository = contactRepository;
    }

    public async Task<List<ServiceDto>> GetServicesListAsync()
    {
        var entity = await _serviceRepository.GetListAsync();

        return ObjectMapper.Map<List<Service>, List<ServiceDto>>(entity);
    }

    public async Task CreateDemoAsync(DemoDto input)
    {
        var demo = ObjectMapper.Map<DemoDto, Demo>(input);
        await _demoRepository.InsertAsync(demo);

        var bodyBuilder = new StringBuilder();
        bodyBuilder.AppendLine($"Şirket: {input.OrganizationName}");
        bodyBuilder.AppendLine($"Ad Soyad: {input.FullName}");
        bodyBuilder.AppendLine($"E-Posta: {input.Email}");
        bodyBuilder.AppendLine($"Telefon: {input.Phone}");
        bodyBuilder.AppendLine($"Adres: {input.Address}");
        bodyBuilder.AppendLine($"Şube Sayısı: {input.NumberOfBranches}");
        bodyBuilder.AppendLine($"Kullanıcı Sayısı: {input.NumberOfUsers}");
        bodyBuilder.AppendLine($"Mesaj: {input.Message}");

        var SenderName = await _settingProvider.GetOrNullAsync(SeedConsts.AbpSettings.Mailing.Default.DefaultFromDisplayName);
        var SenderEmailAddress = await _settingProvider.GetOrNullAsync(SeedConsts.AbpSettings.Mailing.Default.DefaultFromAddress);

        await _emailSender.QueueEmailAsync(
            SenderEmailAddress,
            new KeyValuePair<string, string>(SenderName, SenderEmailAddress),
            null,
            bodyBuilder.ToString(),
            subject: PlatformConsts.AppName + " : Demo Talebi");

    }

    public async Task<BlogPostAndCategoriesDto> GetPostListAsync(GetBlogPostsInput input)
    {
        // IQueryable
        var postQuery = await _postRepository.GetQueryableAsync();

        // 🔎 Arama
        if (!input.Search.IsNullOrWhiteSpace())
        {
            postQuery = postQuery.Where(p =>
                p.ContentTr.Contains(input.Search) ||
                p.ContentEn.Contains(input.Search));
        }

        // 📁 Kategori filtresi
        if (input.CategoryId.HasValue)
        {
            postQuery = postQuery.Where(p => p.CategoryId == input.CategoryId.Value);
        }

        // Toplam adet (sayfalama öncesi)
        var totalCount = await AsyncExecuter.CountAsync(postQuery);

        // Sayfalama + sıralama
        var pagedPosts = await AsyncExecuter.ToListAsync(
            postQuery
                .OrderByDescending(p => p.CreationTime)
                .PageBy(input)
        );

        // Sayfadaki kategori kayıtları
        var categoryIds = pagedPosts.Select(x => x.CategoryId).Distinct().ToList();
        var pageCategories = await _categoryRepository.GetListAsync(x => categoryIds.Contains(x.Id));
        var categoryDict = pageCategories.ToDictionary(x => x.Id, x => x);

        // Post DTO mapping
        var postDtos = pagedPosts.Select(post =>
        {
            var dto = ObjectMapper.Map<BlogPost, BlogPostListDto>(post);
            if (categoryDict.TryGetValue(post.CategoryId, out var c))
            {
                dto.Category = ObjectMapper.Map<BlogCategory, BlogCategoryDto>(c);
            }

            dto.Author = new AuthorDto { Id = post.AuthorId, Name = "User" };
            return dto;
        }).ToList();

        // ----------- KATEGORİLER (PostCount ile) -----------
        var allCategories = await _categoryRepository.GetListAsync();

        var allPostQuery = await _postRepository.GetQueryableAsync();
        var counts = await AsyncExecuter.ToListAsync(
            allPostQuery
                .Where(p => p.IsPublished)
                .GroupBy(p => p.CategoryId)
                .Select(g => new { g.Key, Count = g.Count() })
        );

        var countDict = counts.ToDictionary(x => x.Key, x => x.Count);

        var categoryDtos = ObjectMapper.Map<List<BlogCategory>, List<BlogCategoryDto>>(allCategories);
        foreach (var dto in categoryDtos)
        {
            dto.PostCount = countDict.GetOrDefault(dto.Id);
        }

        return new BlogPostAndCategoriesDto
        {
            Posts = new PagedResultDto<BlogPostListDto>(totalCount, postDtos),
            Categories = categoryDtos
        };
    }

    private async Task<BlogPostDto> GetPostAsync(Guid id)
    {
        var post = await _postRepository.GetAsync(id);
        var dto = ObjectMapper.Map<BlogPost, BlogPostDto>(post);

        // Get category
        dto.Category = ObjectMapper.Map<BlogCategory, BlogCategoryDto>(
            await _categoryRepository.GetAsync(post.CategoryId)
        );

        // Get author info
        dto.Author = new AuthorDto
        {
            Id = post.AuthorId,
            Name = "User"
        };

        return dto;
    }

    public async Task<BlogPostDto> GetPostBySlugAsync(string slug)
    {
        var post = await _postRepository.FirstOrDefaultAsync(x => x.Slug == slug);
        if (post == null)
        {
            throw new EntityNotFoundException(typeof(BlogPost));
        }

        return await GetPostAsync(post.Id);
    }

    public async Task<List<ProductDto>> GetProductListAsync()
    {
        var products = await _productRepository.GetListAsync();

        return ObjectMapper.Map<List<Product>, List<ProductDto>>(products.OrderBy(p => p.Order).ToList());
    }

    public async Task<List<PaymentMethodDto>> GetPaymentMethodListAsync()
    {
        var paymentMethods = await _paymentMethodRepository.GetListAsync();

        return ObjectMapper.Map<List<PaymentMethod>, List<PaymentMethodDto>>(paymentMethods);
    }

    public async Task<List<InstallmentOptionDto>> GetInstallmentOptionListAsync()
    {
        var installmentOptions = await _installmentOptionRepository.GetListAsync();

        return ObjectMapper.Map<List<InstallmentOption>, List<InstallmentOptionDto>>(installmentOptions);
    }

    public async Task<OrderDto> CreateOrderAsync(OrderDto input)
    {
        var entity = new Order()
        {
            TenantId = input.Tenant.Id,
            OrganizationName = input.Tenant.OrganizationName,
            Founder = input.Tenant.Founder,
            VknTckn = input.Tenant.VknTckn,
            TaxOffice = input.Tenant.TaxOffice,
            Address = input.Tenant.Address,
            Address2 = input.Tenant.Address2,
            District = input.Tenant.District,
            Country = input.Tenant.Country,
            City = input.Tenant.City,
            PostalCode = input.Tenant.PostalCode,
            Phone = input.Tenant.Phone,
            Mobile = input.Tenant.Mobile,
            Fax = input.Tenant.Fax,
            Email = input.Tenant.Email,
            Website = input.Tenant.Website,

            Subtotal = input.Subtotal,
            Commission = input.Commission,
            Total = input.Total,
            PaymentMethod = input.PaymentMethod,
            Installments = input.Installments,
            InstallmentName = input.InstallmentName,
            PaymentDataJson = JsonSerializer.Serialize(input.PaymentData),
        };

        foreach (var item in input.Items)
        {
            entity.Items.Add(new OrderItem
            {
                OrderId = entity.Id,
                Order = entity,
                ProductId = item.Product.Id,
                ProductName = item.Product.Name,
                BillingCycle = item.BillingCycle,
                Quantity = item.Quantity,
                TotalPrice = item.TotalPrice
            });
        }

        await _orderRepository.InsertAsync(entity, autoSave: true);

        return new OrderDto
        {
            Id = entity.Id,
            Total = entity.Total,
            PaymentMethod = entity.PaymentMethod
        };
    }

    public async Task<AboutDto> GetAboutAsync()
    {
        var entity = await _aboutRepository.FirstOrDefaultAsync() ?? throw new EntityNotFoundException(typeof(About));
        return ObjectMapper.Map<About, AboutDto>(entity);
    }

    public async Task<ContactDto> GetContactAsync()
    {
        var entity = await _contactRepository.FirstOrDefaultAsync() ?? throw new EntityNotFoundException(typeof(Contact));

        return ObjectMapper.Map<Contact, ContactDto>(entity);
    }
}