hotline/src/Hotline.Api/Controllers/OrderTerminateController.cs

using Hotline.Orders;
using Hotline.Permissions;
using Hotline.Quality;
using Hotline.Share.Dtos.Quality;
using Hotline.Share.Dtos;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using Hotline.Api.Filter;
using Hotline.Caching.Services;
using Hotline.FlowEngine.WorkflowModules;
using Hotline.Repository.SqlSugar.Orders;
using Hotline.Settings;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Order;
using Hotline.Share.Enums.Settings;
using SqlSugar;
using XF.Utility.EnumExtensions;
using MapsterMapper;
using Hotline.File;
using Hotline.Application.FlowEngine;
using Hotline.FlowEngine.Workflows;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Application.Orders;
using Hotline.Share.Requests;
using Hotline.Tools;

namespace Hotline.Api.Controllers
{
	/// <summary>
	/// 终止管理
	/// </summary>
	public class OrderTerminateController : BaseController
	{
		private readonly ISessionContext _sessionContext;
		private readonly IMapper _mapper;
		private readonly IFileRepository _fileRepository;
		private readonly IWorkflowApplication _workflowApplication;
		private readonly IRepository<Workflow> _workflowRepository;
		private readonly IWorkflowDomainService _workflowDomainService;
		private readonly IOrderRepository _orderRepository;
		private readonly IOrderDomainService _orderDomainService;
		private readonly IOrderTerminateRepository _orderTerminateRepository;
		private readonly IOrderApplication _orderApplication;

		public OrderTerminateController(
			ISessionContext sessionContext,
			IMapper mapper,
			IFileRepository fileRepository,
			IWorkflowApplication workflowApplication,
			IRepository<Workflow> workflowRepository,
			IWorkflowDomainService workflowDomainService,
			IOrderRepository orderRepository,
			IOrderDomainService orderDomainService,
			IOrderTerminateRepository orderTerminateRepository,
			IOrderApplication orderApplication
			) 
		{ 
			_sessionContext = sessionContext;
			_mapper = mapper;
			_fileRepository = fileRepository;
			_workflowApplication = workflowApplication;
			_workflowRepository = workflowRepository;
			_workflowDomainService = workflowDomainService;
			_orderRepository = orderRepository;
			_orderDomainService = orderDomainService;
			_orderTerminateRepository = orderTerminateRepository;
			_orderApplication= orderApplication;
		}

		/// <summary>
		/// 工单终止待申请列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet("may-terminate")]
		public async Task<PagedDto<OrderDto>> MayOrderTerminateList([FromQuery] OrderTerminateListDto dto)
		{
			var isAdmin = _orderDomainService.IsCheckAdmin();
			var (total, items) =await _orderRepository.Queryable(isAdmin:isAdmin)
				.Includes(d=>d.OrderTerminates)
				.Where(d=> SqlFunc.Subqueryable<OrderTerminate>().Where(t=> t.OrderId  == d.Id && t.Status != ETerminateStatus.SendBackStart).NotAny())
				.Where(d => d.Status >= EOrderStatus.Filed && d.ActualHandleOrgCode.StartsWith(_sessionContext.OrgId))
				.WhereIF(!string.IsNullOrEmpty(dto.No),d=>d.No!.Contains(dto.No!))
				.WhereIF(!string.IsNullOrEmpty(dto.Title), d => d.Title!.Contains(dto.Title!))
				.WhereIF(dto.ApplyStartTime.HasValue && dto.ApplyEndTime.HasValue,
					d => d.OrderTerminates.Any(t=>t.CreationTime >= dto.ApplyStartTime && t.CreationTime<= dto.ApplyEndTime))
				.WhereIF(dto.StartTime.HasValue && dto.EndTime.HasValue,d=>d.StartTime >= dto.StartTime && d.StartTime <= dto.EndTime)
				.OrderByDescending(d => d.StartTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
		}


		/// <summary>
		/// 工单终止列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet]
		public async Task<PagedDto<OrderTerminateEntityDto>> OrderTerminateList([FromQuery] OrderTerminateListDto dto)
		{
			var (total, items) = await _orderApplication.OrderTerminateList(dto)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<OrderTerminateEntityDto>(total, _mapper.Map<IReadOnlyList<OrderTerminateEntityDto>>(items));
		}

		/// <summary>
		/// 工单终止列表导出
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>

		[HttpPost("export")]
		public async Task<FileStreamResult> OrderTerminateListExport([FromBody] ExportExcelDto<OrderTerminateListDto> dto)
		{
			var query = _orderApplication.OrderTerminateList(dto.QueryDto);
			List<OrderTerminate> data;
			if (dto.IsExportAll)
			{
				data = await query.ToListAsync(HttpContext.RequestAborted);
			}
			else
			{
				var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
				data = items;
			}

			var dataDtos = _mapper.Map<ICollection<OrderTerminateEntityDto>>(data);

			dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass(dto.ColumnInfos);

			var dtos = dataDtos
				.Select(stu => _mapper.Map(stu, typeof(OrderTerminateEntityDto), dynamicClass))
				.Cast<object>()
				.ToList();

			var stream = ExcelHelper.CreateStream(dtos);

			return ExcelStreamResult(stream, "工单终止列表");
		}


		/// <summary>
		/// 开始工单终止流程
		/// </summary>
		[HttpPost("startflow")]
		[LogFilter("开始工单终止流程")]
		public async Task StartFlow([FromBody] StartWorkflowDto<OrderTerminateDto> dto)
		{
			var screenAny = await _orderTerminateRepository.AnyAsync(x =>
				x.OrderId == dto.Data.OrderId && x.Status == ETerminateStatus.Approval);
			if (screenAny)
				throw UserFriendlyException.SameMessage("该工单已提起终止申请，正在审批过程中，不能申请");

			var isNoPass = await _orderTerminateRepository.AnyAsync(x => x.Status ==  ETerminateStatus.Refuse && x.OrderId == dto.Data.OrderId);
			if (isNoPass)
				throw UserFriendlyException.SameMessage("该工单已被拒绝过甄别申请，不能再次申请");

			var model = _mapper.Map<OrderTerminate>(dto.Data);
			model.Status = ETerminateStatus.Approval ;
			model.InitId();
			if (dto.Data.Files.Any())
				model.FileJson = await _fileRepository.AddFileAsync(dto.Data.Files, model.Id, "", HttpContext.RequestAborted);
			else
				model.FileJson = new List<Share.Dtos.File.FileJson>();
			await _orderTerminateRepository.AddAsync(model, HttpContext.RequestAborted);
			try
			{
				var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
				startDto.DefinitionModuleCode = WorkflowModuleConsts.OrderTerminate;
				startDto.Opinion = dto.Data.Content;
				startDto.Title = "申请终止流程";
				await _workflowApplication.StartWorkflowAsync(startDto, model.Id, cancellationToken: HttpContext.RequestAborted);
			}
			catch (Exception e)
			{
				await _orderTerminateRepository.RemoveAsync(model.Id);
				model.Id = string.Empty;
				throw new UserFriendlyException($"工单开启终止流程失败!, {e.Message}", "工单开启终止流程失败");
			}
		}


		/// <summary>
		/// 工单终止修改后下一步流程
		/// </summary>
		[HttpPost("initial_nextFlow")]
		[LogFilter("办理工单终止流程")]
		public async Task InitialNextFlow([FromBody] TerminateNextFlowDto dto)
		{
			var model = await _orderTerminateRepository.GetAsync(dto.Data.Id);

			if (dto.Data.Files.Any())
				model.FileJson = await _fileRepository.AddFileAsync(dto.Data.Files, model.Id, "", HttpContext.RequestAborted);
			else
				model.FileJson = new List<Share.Dtos.File.FileJson>();

			model.Content = dto.Data.Content;
			model.IsRecommit = true;
			await _orderTerminateRepository.UpdateAsync(model, HttpContext.RequestAborted);
			try
			{
				dto.NextWorkflow.WorkflowId = model.WorkflowId;
				await _workflowDomainService.NextAsync(_sessionContext, dto.NextWorkflow, cancellationToken: HttpContext.RequestAborted);
			}
			catch (Exception e)
			{
				throw new UserFriendlyException($"工单终止下一步流程失败!, {e.Message}", "工单终止下一步流程失败");
			}
		}

		/// <summary>
		/// 查询工单终止流程开启参数
		/// </summary>
		/// <returns></returns>
		[HttpGet("screen/startflow")]
		public async Task<NextStepsDto> GetTerminateFlowStartOptionsAsync()
		{
			return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.OrderTerminate,
				HttpContext.RequestAborted);
		}

		/// <summary>
		/// 查询工单终止流程参数
		/// </summary>
		/// <returns></returns>
		[HttpGet("workflow/{id}")]
		public async Task<string> GetTerminateWorkFlowAsync(string id)
		{
			var workflow = await _workflowRepository.Queryable().FirstAsync(x => x.ExternalId == id);
			return workflow.Id;
		}

		/// <summary>
		///  甄别查询流程办理下一步可选节点
		/// </summary>
		/// <param name="workflowId"></param>
		/// <returns></returns>
		[HttpGet("{workflowId}/nextsteps")]
		public async Task<NextStepsDto> OrderTerminateNextsteps(string workflowId)
		{
			return await _workflowApplication.GetNextStepsAsync(workflowId, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 终止详情
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("{id}")]
		public async Task<OrderTerminateEntityDto> Entity(string id)
		{
			var model = await _orderTerminateRepository.Queryable()
				.Includes(x => x.Order) 
				.Includes(x => x.Workflow, d => d.Steps)
				.FirstAsync(x => x.Id == id);
			var rspModel = _mapper.Map<OrderTerminateEntityDto>(model);
			rspModel.IsCanHandle = model.Workflow?.IsCanHandle(
				_sessionContext.RequiredUserId, _sessionContext.RequiredOrgId, _sessionContext.Roles) ?? false;
			if (model.Status ==  ETerminateStatus.SendBackStart)
				rspModel.IsCanHandle = false;
			rspModel.Handle = false;
			if (!string.IsNullOrEmpty(rspModel.WorkflowId))
			{
				rspModel.Handle = await _workflowDomainService.CheckCurrentIsStartStepAsync(rspModel.WorkflowId, _sessionContext.RequiredUserId,
					_sessionContext.RequiredOrgId, HttpContext.RequestAborted);
			}

			if (rspModel.FileJson != null && rspModel.FileJson.Any())
			{
				var ids = rspModel.FileJson.Select(x => x.Id).ToList();
				rspModel.Files = await _fileRepository.GetFilesAsync(ids, HttpContext.RequestAborted);
			}
			return rspModel;
		}

		/// <summary>
		/// 列表页面基础数据
		/// </summary>
		/// <returns></returns>
		[HttpGet("base")]
		public async Task<object> BaseData()
		{
			var rsp = new
			{
				Status = EnumExts.GetDescriptions<ETerminateStatus>(),
			};
			return rsp;
		}

		/// <summary>
		/// 终止修改理由
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut("update_content")]
		[LogFilter("终止修改理由")]
		public async Task Update([FromBody] OrderTerminateContentDto dto)
		{
			await _orderTerminateRepository.Updateable().SetColumns(x => new OrderTerminate { Content = dto.Content }).Where(x => x.Id == dto.Id).ExecuteCommandAsync();
		}

	}
}