SHJX_GM/SHJX.Service.Control/Extends/CalculationResult.cs

namespace SHJX.Service.Control.Extends
{
    /// <summary>
    /// 计算结果
    /// </summary>
    public class CalculationResult
    {
        private static IDataManager _dataManager;
        public CalculationResult(IDataManager dataManager)
        {
            _dataManager = dataManager;
        }

        public static double CalculateCalibration(EquipmentTask task)
        {
            double k = CalculateType(task.WaveKey, TaskTypeName.CALIBRATION_ZH, (arg) => 10 / arg);
            EquipmentTask blankTask = _dataManager.Query<EquipmentTask>().Where(it => it.WaveKey.Equals(task.WaveKey) && it.Source.Equals(task.Source) && it.TaskType.Equals(TaskTypeName.BLANK_ZH) && it.Status.In(TaskState.Execute,TaskState.Finished)).First();
            double taskRes = (10 + blankTask.Amount) * k - 10;
            double ret = (taskRes * 0.01 * 8 * 1000) / blankTask.SampleVolume;
            return ret;
        }

        public static double CalculateBlank(EquipmentTask task)
        {
            double k = CalculateType(task.WaveKey, TaskTypeName.CALIBRATION_ZH, (arg) => 10 / arg);
            double taskRes = (10 + task.Amount) * k - 10;
            double ret = (taskRes * 0.01 * 8 * 1000) / task.SampleVolume;
            return ret;
        }

        public static double CalculateSample(EquipmentTask task)
        {
            double k = CalculateType(task.WaveKey, TaskTypeName.CALIBRATION_ZH, (arg) => 10 / arg);
            return CalculateSample(task, k);
        }

        public static double CalculateSample(EquipmentTask task, double k)
        {
            double blank = CalculateType(task.WaveKey, TaskTypeName.BLANK_ZH, (arg) => arg);
            double taskRes = (10 + task.Amount) * k - 10;
            double blankRes = ((10 + blank) * k - 10) * task.SampleMultiple;
            double ret = ((taskRes - blankRes) * 0.01 * 8 * 1000) / task.SampleVolume;
            return ret;
        }

        public static double CalculateType(string key, string type, Func<double, double> func)
        {
            List<EquipmentTask> tasks = _dataManager.Query<EquipmentTask>().Where(it => it.WaveKey.Equals(key) && it.TaskType.Equals(type) && it.Status.Equals(TaskState.Finished)).ToList();
            if (!tasks.Any())
            {
                tasks = _dataManager.Query<EquipmentTask>().Where(it => it.TaskType.Equals(type)).With(a => a.WaveKey, b => b.WaveKey, _dataManager.Query<EquipmentTask>().Where(it => it.TaskType.Equals(type) && it.Status.Equals(TaskState.Finished)).OrderBy(it => it.CreateTime, OrderPattern.Desc).Take(1), WithPattern.Equals).ToList();
                if (!tasks.Any())
                {
                    return 0;
                }
            }
            double avg = 0;
            return CalculateType(tasks, func, ref avg);
        }

        public static double CalculateType(List<EquipmentTask> tasks, Func<double, double> func, ref double avgRes)
        {
            double volumeSum = 0.0;
            volumeSum = tasks.Sum(it => it.Amount);
            if (volumeSum.Equals(0))
            {
                return 0;
            }
            avgRes = volumeSum / tasks.Count;
            double returnResult = func.Invoke(avgRes);
            return Math.Round(returnResult, 2);
        }
    }
}