XdCxRhDW/XdCxRhDW.App/WebAPI/Controllers/DetectCgController.cs

using PosResAnalysis;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDw.Dto;
using XdCxRhDW.App.CorTools;
using System.Web;
using Newtonsoft.Json.Linq;
using XdCxRhDW.App.CpuCgTools;
namespace XdCxRhDW.App.WebAPI
{
    /// <summary>
    /// 检测参估功能相关接口
    /// </summary>
    public class DetectCgController : BaseController
    {

        private string UploadFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UploadFolder");
        private (bool, string) ValidateCalcParam(CalcDto dto)
        {
            if (dto == null)
            {
                return (false, "参估计算参数格式错误!");
            }
            if (string.IsNullOrEmpty(dto.file1))
            {
                return (false, "参估计算参数数据文件[file1]不能为空!");
            }
            if (string.IsNullOrEmpty(dto.file2))
            {
                return (false, "参估计算参数数据文件[file2]不能为空!");
            }
            if (!File.Exists(dto.file1))
            {
                return (false, $"参估计算参数数据文件[{dto.file1}]不存在!");
            }
            if (!File.Exists(dto.file2))
            {
                return (false, $"参估计算参数数据文件[{dto.file2}]不存在!");
            }
            if (dto.dtRange <= 0)
            {
                return (false, "参估计算参数时差范围[dtRange]不能小于等于0!");
            }
            if (dto.smpStart < 0)
            {
                return (false, "参估计算参数开始样点[smpStart]不能小于0!");
            }
            if (dto.smpCount < 0)
            {
                return (false, "参估计算参数样点数[smpCount]不能小于0!");
            }
            return (true, string.Empty);
        }
        /// <summary>
        /// 参估计算
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<EstimationResDto>> EstimationCalc(CalcDto dto)
        {
            var vpres = ValidateCalcParam(dto);
            if (!vpres.Item1)
            {
                Serilog.Log.Warning(vpres.Item2);
                return Error<EstimationResDto>(vpres.Item2);
            }
            XcorrStruct xItem = new XcorrStruct();
            xItem.file1 = dto.file1;
            xItem.file2 = dto.file2;
            xItem.samplingRate = dto.samplingRate;
            xItem.dtCenter = dto.dtCenter;
            xItem.dtRange = dto.dtRange;
            xItem.dfRange = dto.dfRange;
            //样点数为0时计算所有样本
            if (dto.smpCount == 0)
            {

                FileInfo file = new FileInfo(dto.file1);
                long totalsamp = file.Length / 4;
                xItem.smpCount = (int)totalsamp - dto.smpStart;
            }
            else
            {
                xItem.smpCount = dto.smpCount;
            }
            xItem.smpStart = dto.smpStart;
            xItem.snrThreshold = dto.snrThreshold;

            var result = await XcorrUtils.Calc(xItem);
            //开始计算
            if (result.flag == -2)
            {
                Serilog.Log.Warning("参估计算内部错误!");
                return Error<EstimationResDto>("参估计算内部错误!");
            }
            else if (result.flag == -1)
            {
                Serilog.Log.Warning("参估计算所需数据超出文件范围!");
                return Error<EstimationResDto>("参估计算所需数据超出文件范围!");
            }
            EstimationResDto resDto = new EstimationResDto();
            resDto.Tm = result.tm;
            resDto.Smpstart = result.smpstart;
            resDto.Smplen = result.smplen;
            resDto.File1 = result.file1;
            resDto.File2 = result.file2;
            if (result.flag == 1)
            {
                resDto.Dt = result.dt.Value;
                resDto.Df = result.df.Value;
                resDto.Snr = result.snr.Value;
            }
            try
            {
                //删除计算得文件
                File.Delete(dto.file1);
                File.Delete(dto.file2);
            }
            catch 
            {
            }
            return Success(resDto);

        }


        private (bool, string) ValidateDetectParam(DetectDto dto)
        {
            if (dto == null)
            {
                return (false, "检测计算参数格式错误!");
            }
            if (string.IsNullOrEmpty(dto.file1))
            {
                return (false, "检测计算参数数据文件[file1]不能为空!");
            }
            if (!File.Exists(dto.file1))
            {
                return (false, $"检测计算参数数据文件[{dto.file1}]不存在!");
            }
            bool containsValue = Enum.IsDefined(typeof(DmcType), dto.dmcType); 
            if (!containsValue)
            {
                return (false, $"检测计算参数[dmcType]检测类型值{dto.dmcType}不存在!");
            }
          
            return (true, string.Empty);
        }

        /// <summary>
        /// 检测计算
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<IEnumerable<DetectResDto>>> DetectCalc(DetectDto dto)
        {
            var vpres = ValidateDetectParam(dto);
            if (!vpres.Item1)
            {
                Serilog.Log.Warning(vpres.Item2);
                return Error<IEnumerable<DetectResDto>>(vpres.Item2);
            }
            List<DetectResDto> list = new List<DetectResDto>();
            try
            {
                var dmcResult = await XcorrUtils.DmcCheckAsync(dto.file1, dto.dmcType);
                foreach (var dmcItem in dmcResult)
                {
                    DetectResDto detectRes = new DetectResDto(dmcItem.Start, dmcItem.Length, dmcItem.UserName);
                    detectRes.File1 = dto.file1;
                    list.Add(detectRes);

                }
            }
            catch (Exception ex)
            {
                return Error<IEnumerable<DetectResDto>>($"执行检测计算异常,{ex.Message}");
            }
            finally
            {
                try
                {
                    //删除检测的文件
                    File.Delete(dto.file1);
                }
                catch
                {
                }
            }
           
            return Success<IEnumerable<DetectResDto>>(list);

        }


        /// <summary>
        /// 上传文件
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<string>> UploadFile()
        {
            if (!Request.Content.IsMimeMultipartContent("form-data"))
            {
                return Error<string>("请求数据不是multipart/form-data类型");
            }
            var provider = new MultipartMemoryStreamProvider();
            await Request.Content.ReadAsMultipartAsync(provider);

            // 创建文件夹（如果尚未存在）
            if (!Directory.Exists(UploadFolder))
            {
                Directory.CreateDirectory(UploadFolder);
            }
            var content = provider.Contents.First();
            var fileName = GetFileName(content.Headers);
            var fileData = await content.ReadAsByteArrayAsync();

            // 将文件保存到本地文件夹中
            var filePath = Path.Combine(UploadFolder, fileName);
            using (var fileStream = new FileStream(filePath, FileMode.Create))
            {
                await fileStream.WriteAsync(fileData, 0, fileData.Length);
            }

            return Success<string>(filePath);
        }

        private string GetFileName(System.Net.Http.Headers.HttpContentHeaders headers)
        {
            var disposition = headers.ContentDisposition;
            var fileName = disposition.FileName.Trim('"');

            // 如果 fileName 为空，则可以根据需要生成唯一的文件名
            if (string.IsNullOrEmpty(fileName))
            {
                fileName = Guid.NewGuid().ToString();
            }

            return fileName;
        }
    }
}