hotline/src/Hotline.Application/Handlers/Order/ProvinceOrderSuperviseNotifyHandler.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Hotline.DataSharing.Province.Notifications;
using Hotline.File;
using Hotline.Orders;
using Hotline.Settings;
using MediatR;
using Microsoft.AspNetCore.Http;
using XF.Domain.Repository;

namespace Hotline.Application.Handlers.Order
{
    public class ProvinceOrderSuperviseNotifyHandler : INotificationHandler<ProvinceOrderSuperviseNotify>
    {
        private readonly IOrderRepository _orderRepository;
        private readonly IRepository<OrderSupervise> _orderSuperviseRepository;
        private readonly ISystemOrganizeRepository _organizeRepository;
        private readonly IFileRepository _fileRepository;

		public ProvinceOrderSuperviseNotifyHandler(
            IOrderRepository orderRepository,
            IRepository<OrderSupervise> orderSuperviseRepository,
            ISystemOrganizeRepository organizeRepository,
            IFileRepository fileRepository)
        {
            _orderRepository = orderRepository;
            _orderSuperviseRepository = orderSuperviseRepository;
            _organizeRepository = organizeRepository;
            _fileRepository = fileRepository; 

		}

        /// <summary>Handles a notification</summary>
        /// <param name="notification">The notification</param>
        /// <param name="cancellationToken">Cancellation token</param>
        public async Task Handle(ProvinceOrderSuperviseNotify notification, CancellationToken cancellationToken)
        {
            var dto = notification.ProvinceOrderSuperviseDto;
            var files = notification.Files;
            var order = await _orderRepository.Queryable().Where(x => x.ProvinceNo == dto.CaseSerial).FirstAsync(cancellationToken);
            var org = await _organizeRepository.Queryable().Where(x => x.Name == dto.SuperviseRsvDept).FirstAsync(cancellationToken);
            var orderSupervise = await _orderSuperviseRepository.GetAsync(x => x.SuperviseSerial == dto.SuperviseSerial);
            if (orderSupervise is null)
            {
                var model = new OrderSupervise
                {
                    OrderId = order.Id,
                    ReplyLimitTime = dto.SuperviseReturnDate,
                    OrgId = org.Id,
                    OrgName = org.Name,
                    LaunchOrgName = dto.SuperviseSendDept,
                    State = 0,
                    ApplyContent = dto.SuperviseContent,
                    CrUser = dto.SupervisePerson,
                    SuperviseSerial = dto.SuperviseSerial
                };
                model.InitId();
                if(files != null && files.Any()) model.FileJson = await _fileRepository.AddFileAsync(files, model.Id, cancellationToken);
				await _orderSuperviseRepository.AddAsync(model, cancellationToken);
            }
            else {
				if (files != null && files.Any()) orderSupervise.FileJson = await _fileRepository.AddFileAsync(files, orderSupervise.Id, cancellationToken);
				await _orderSuperviseRepository.UpdateAsync(orderSupervise, cancellationToken);
			}
          
        }
    }
}