Mango.Nop.Plugins/Nop.Plugin.Misc.AIPlugin/Areas/Admin/Controllers/CustomOrderController.cs

using AyCode.Services.SignalRs;
using FruitBank.Common.Dtos;
using FruitBank.Common.Interfaces;
using FruitBank.Common.Server.Interfaces;
using FruitBank.Common.SignalRs;
using Microsoft.AspNetCore.Mvc;
using Nop.Core.Domain.Orders;
using Nop.Core.Domain.Payments;
using Nop.Core.Domain.Shipping;
using Nop.Core.Domain.Tax;
using Nop.Plugin.Misc.FruitBankPlugin.Domains.DataLayer;
using Nop.Plugin.Misc.FruitBankPlugin.Factories;
using Nop.Plugin.Misc.FruitBankPlugin.Models;
using Nop.Services.Common;
using Nop.Services.Customers;
using Nop.Services.Messages;
using Nop.Services.Orders;
using Nop.Services.Security;
using Nop.Web.Areas.Admin.Controllers;
using Nop.Web.Areas.Admin.Factories;
using Nop.Web.Areas.Admin.Models.Orders;
using Nop.Web.Framework;
using Nop.Web.Framework.Mvc.Filters;

namespace Nop.Plugin.Misc.FruitBankPlugin.Areas.Admin.Controllers
{
    [Area(AreaNames.ADMIN)]
    [AuthorizeAdmin]
    public class CustomOrderController : BaseAdminController, ICustomOrderSignalREndpointServer
    {
        private readonly IOrderService _orderService;
        private readonly CustomOrderModelFactory _orderModelFactory;
        private readonly ICustomOrderSignalREndpointServer _customOrderSignalREndpoint;
        private readonly IPermissionService _permissionService;
        private readonly IGenericAttributeService _genericAttributeService;
        private readonly INotificationService _notificationService;
        private readonly ICustomerService _customerService;
        // ... other dependencies

        public CustomOrderController(IOrderService orderService, IOrderModelFactory orderModelFactory, ICustomOrderSignalREndpointServer customOrderSignalREndpoint, IPermissionService permissionService, IGenericAttributeService genericAttributeService, INotificationService notificationService, ICustomerService customerService)
        {
            _orderService = orderService;
            _orderModelFactory = orderModelFactory as CustomOrderModelFactory;
            _customOrderSignalREndpoint = customOrderSignalREndpoint;
            _permissionService = permissionService;
            _genericAttributeService = genericAttributeService;
            _notificationService = notificationService;
            _customerService = customerService;
            // ... initialize other deps
        }

        #region CustomOrderSignalREndpoint
        [NonAction] public Task<List<OrderDto>> GetAllOrderDtos() => _customOrderSignalREndpoint.GetAllOrderDtos();
        [NonAction]public Task<OrderDto> GetOrderDtoById(int orderId) => _customOrderSignalREndpoint.GetOrderDtoById(orderId);
        [NonAction]public Task<List<OrderDto>> GetPendingOrderDtos() => _customOrderSignalREndpoint.GetPendingOrderDtos();
        [NonAction] public Task<List<OrderDto>> GetAllByIds(int[] orderIds) => _customOrderSignalREndpoint.GetAllByIds(orderIds);
        #endregion CustomOrderSignalREndpoint

        [CheckPermission(StandardPermission.Orders.ORDERS_VIEW)]
        public virtual async Task<IActionResult> List(List<int> orderStatuses = null, List<int> paymentStatuses = null, List<int> shippingStatuses = null)
        {
            //prepare model
            var model = await _orderModelFactory.PrepareOrderSearchModelAsync(new OrderSearchModel
            {
                OrderStatusIds = orderStatuses,
                PaymentStatusIds = paymentStatuses,
                ShippingStatusIds = shippingStatuses,
            });            

            return View("~/Plugins/Misc.FruitBankPlugin/Areas/Admin/Views/Order/List.cshtml", model);
        }

        [HttpPost]
        [CheckPermission(StandardPermission.Orders.ORDERS_VIEW)]
        public async Task<IActionResult> OrderList(OrderSearchModel searchModel)
        {
            //prepare model
            var orderListModel = await GetOrderListModelByFilter(searchModel);
            //var orderListModel = new OrderListModel();
            
            var valami = Json(orderListModel);
            Console.WriteLine(valami);
            return valami;
        }

        public async Task<OrderListModelExtended> GetOrderListModelByFilter(OrderSearchModel searchModel)
        {
            //return _customOrderService.
            var orderListModel = await _orderModelFactory.PrepareOrderListModelExtendedAsync(searchModel);
            
            Console.WriteLine($"Total: {orderListModel.RecordsTotal}, Data Count: {orderListModel.Data.Count()}");
            foreach (var item in orderListModel.Data.Take(3))
            {
                Console.WriteLine($"Order: {item.Id}, {item.CustomOrderNumber}");
            }

            return orderListModel;
        }

        public virtual IActionResult Test()
        {
            // Your custom logic here
            // This will use your custom List.cshtml view
            return View("~/Plugins/Misc.FruitBankPlugin/Areas/Admin/Views/Order/Test.cshtml");
        }

        //[HttpPost]
        //[CheckPermission(Nop.Services.Security.StandardPermission.Orders.ORDERS_VIEW)]
        //public virtual async Task<IActionResult> OrderList(OrderSearchModel searchModel)
        //{
        //    //prepare model
        //    var model = await _orderModelFactory.PrepareOrderListModelAsync(searchModel);

        //    return Json(model);
        //}

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> SaveOrderAttributes(OrderAttributesModel model)
        {
            if (!ModelState.IsValid)
            {
                // reload order page with errors
                return RedirectToAction("Edit", "Order", new { id = model.OrderId });
            }

            var order = await _orderService.GetOrderByIdAsync(model.OrderId);
            if (order == null)
                return RedirectToAction("List", "Order");

            // store attributes in GenericAttribute table
            await _genericAttributeService.SaveAttributeAsync(order, nameof(OrderModelExtended.IsMeasurable), model.IsMeasurable);
            await _genericAttributeService.SaveAttributeAsync(order, nameof(IOrderDto.DateOfReceipt), model.DateOfReceipt);

            _notificationService.SuccessNotification("Custom attributes saved successfully.");

            return RedirectToAction("Edit", "Order", new { id = model.OrderId });
        }

        [HttpPost]
        public virtual async Task<IActionResult> Create(int customerId)
        {
            if (!await _permissionService.AuthorizeAsync(StandardPermission.Orders.ORDERS_CREATE_EDIT_DELETE))
                return AccessDeniedView();

            // Validate customer exists
            var customer = await _customerService.GetCustomerByIdAsync(customerId);
            if (customer == null)
                return RedirectToAction("List");

            // Create new empty order
            var order = new Order
            {
                OrderGuid = Guid.NewGuid(),
                CustomerId = customerId,
                CustomerLanguageId = customer.LanguageId ?? 1,
                CustomerTaxDisplayType = (TaxDisplayType)customer.TaxDisplayType,
                CustomerIp = string.Empty,
                OrderStatusId = (int)OrderStatus.Pending,
                PaymentStatusId = (int)PaymentStatus.Pending,
                ShippingStatusId = (int)ShippingStatus.ShippingNotRequired,
                CreatedOnUtc = DateTime.UtcNow,
                BillingAddressId = customer.BillingAddressId ?? 0,
                ShippingAddressId = customer.ShippingAddressId
            };

            await _orderService.InsertOrderAsync(order);

            // Redirect to edit page
            return RedirectToAction("Edit", new { id = order.Id });
        }


        [HttpGet]  // Change from [HttpPost] to [HttpGet]
        [CheckPermission(StandardPermission.Customers.CUSTOMERS_VIEW)]
        public virtual async Task<IActionResult> CustomerSearchAutoComplete(string term)
        {
            if (string.IsNullOrWhiteSpace(term) || term.Length < 2)
                return Json(new List<object>());

            const int maxResults = 15;

            // Search by email (contains)
            var customersByEmail = await _customerService.GetAllCustomersAsync(
                email: term,
                pageIndex: 0,
                pageSize: maxResults);

            // Search by first name (contains)
            var customersByFirstName = await _customerService.GetAllCustomersAsync(
                firstName: term,
                pageIndex: 0,
                pageSize: maxResults);

            // Search by last name (contains)
            var customersByLastName = await _customerService.GetAllCustomersAsync(
                lastName: term,
                pageIndex: 0,
                pageSize: maxResults);

            // Combine and deduplicate results
            var allCustomers = customersByEmail
                .Union(customersByFirstName)
                .Union(customersByLastName)
                .DistinctBy(c => c.Id)
                .Take(maxResults)
                .ToList();

            var result = new List<object>();
            foreach (var customer in allCustomers)
            {
                var fullName = await _customerService.GetCustomerFullNameAsync(customer);
                var displayText = !string.IsNullOrEmpty(customer.Email)
                    ? $"{customer.Email} ({fullName})"
                    : fullName;

                result.Add(new
                {
                    label = displayText,
                    value = customer.Id
                });
            }

            return Json(result);
        }

    }
}