TFT_PlcItemAutoTest/BlankApp1/BlankApp1/ViewModels/StatisticsViewModel.cs

using AutoMapper;
using BizService;
using LiveCharts;
using LiveCharts.Defaults;
using LiveCharts.Wpf;
using Microsoft.Extensions.Logging;
using Model.Dto;
using Model.Entities;
using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BlankApp1.ViewModels
{
    public  class StatisticsViewModel:BindableBase
    {
        private readonly IDialogService _dialog;
        private readonly IOptionConfigService _optionConfigService;
        private readonly IBasicPlcTestSchemeService _basicPlcTestSchemeService;
        private readonly IBasicPlcTestSchemeDtlService _basicPlcTestSchemeDtlService;
        private readonly IBizTestRecordDtlService _iBizTestRecordDtlService;
        private readonly IBasicDeviceService _iBasicDeviceService;
        private readonly IBasicDeviceKindService _iBasicDeviceKindService;
        private readonly IBasicProjectService _iBasicProjectService;
        private readonly IBizTestRecordService _iBizTestRecordService;
        private readonly IBasicPlcTestSchemeDtlService _iBasicPlcTestSchemeDtlService;
        private readonly ILogger _logger;
        private readonly IMapper _mapper;

        private List<DeviceDtlWithResultModel> allDeviceList = new List<DeviceDtlWithResultModel>();//所有方案
        private List<DeviceDtlWithResultModel> conditionDevices = new List<DeviceDtlWithResultModel>();//符合条件的方案
        private int allSchCount = 0; //所有测试项
        public StatisticsViewModel(IDialogService dialog, IMenuService menuService, IOptionConfigService optionConfigService, IBasicPlcTestSchemeService basicPlcTestSchemeService, IBasicPlcTestSchemeDtlService basicPlcTestSchemeDtlService, IBizTestRecordDtlService iBizTestRecordDtlService, IBasicDeviceKindService iBasicDeviceKindService, IBasicProjectService iBasicProjectService, IBizTestRecordService iBizTestRecordService, IBasicPlcTestSchemeDtlService iBasicPlcTestSchemeDtlService, IBasicDeviceService iBasicDeviceService,IMapper mapper, ILogger logger)
        {
            _dialog = dialog;
            _optionConfigService = optionConfigService;
            _basicPlcTestSchemeService = basicPlcTestSchemeService;
            _basicPlcTestSchemeDtlService = basicPlcTestSchemeDtlService;
            _iBizTestRecordDtlService = iBizTestRecordDtlService;

             _iBasicDeviceKindService= iBasicDeviceKindService;
            _iBasicProjectService = iBasicProjectService;
            _iBizTestRecordService = iBizTestRecordService;
            _iBasicPlcTestSchemeDtlService = iBasicPlcTestSchemeDtlService;
            _iBasicDeviceService = iBasicDeviceService;
            _logger = logger;
            _mapper = mapper;
            PieSeriesCollectionDone = new SeriesCollection();
            PieSeriesCollectionFail= new SeriesCollection();
            PieSeriesCollectionEveryday = new SeriesCollection();
            PieSeriesCollectionPLC = new SeriesCollection();
            OnLoadCommand = new DelegateCommand(OnLoad);
     
        }

        private void OnLoad()
        {
            GetProjectConfig();
            GetPieSeriesDone();
            GetPieSeriesPLC();
            GetPieSeriesEveryDay();
            GetPieSeriesFail();
        }
 
        /// <summary>
        /// 获取所有项目
        /// </summary>
        private void GetProjectConfig()
        {
            allDeviceList.Clear();
            conditionDevices.Clear();
            //所有测试方案
            var schlist = _basicPlcTestSchemeService.QueryList();
            var schDtoList = _mapper.Map<List<bas_plc_test_scheme>, List<BasicPlcTestSchemeDto>>(schlist);
            //测试记录中的所有设备
            var deviceIds = _iBizTestRecordService.QueryList().Select(X => X.device_id).Distinct();
            foreach (var deviceId in deviceIds)
            {
                var deviceMsg = _iBasicDeviceService.Find(((int)deviceId));
                if (deviceMsg != null)
                {
                    //查找哦记录有的方案

                    var recordMsgs = _iBizTestRecordService.FindRecordByDeviceId(deviceId);
                    foreach (var sch in recordMsgs)
                    {
                        string deviceKindName = _iBasicDeviceKindService.Find((int)deviceMsg.device_kind_id)?.devicekind_name;
                        string projectName = _iBasicProjectService.Find((int)deviceMsg.project_id)?.project_name;
                        long schId = (long)_basicPlcTestSchemeService.FindByNameAndType(sch.scheme_name, deviceKindName)?.scheme_id;
                        //计算测试结果
                        string testResult = string.Empty;
                        int countResult = 0;
                        var records = _iBizTestRecordDtlService.FindRecordDetailByRecordID(sch.record_id);
                        //
                        var schDtls = _iBasicPlcTestSchemeDtlService.FindAllBySchId(schId);
                        //循环所有测试项，有一个不合格，则整个测试方案不合格
                        foreach (var dtl in schDtls)
                        {
                            //选取开始时间最大的一个数据,查看测试结果
                            long schDtId = dtl.scheme_dtl_id;
                            var findRecords = records.FindAll(x => x.scheme_dtl_id == schDtId).OrderByDescending(x => x.start_test_time).ToArray();
                            if (findRecords.Length > 0)
                            {
                                int result = (int)findRecords[0]?.test_result.Value;
                                if (result == 0)
                                {
                                    testResult = "不通过";
                                    break;
                                }
                                else
                                {
                                    countResult++;
                                }
                            }
                        }
                        //测试结果
                        if (countResult == schDtls.Count)
                        {
                            testResult = "通过";
                        }


                        allDeviceList.Add(new DeviceDtlWithResultModel()
                        {
                            RecordId = sch.record_id,
                            DeviceId = deviceMsg.device_id,
                            DeviceNo = deviceMsg.device_no,
                            DeviceName = deviceMsg.device_name,
                            DeviceKindName = deviceKindName,
                            ProjectName = projectName,
                            SchemeName = sch.scheme_name,
                            SchemeId = schId,
                            StartTestTime = sch.start_test_time.Value,
                            TestResult = testResult
                        });
                        conditionDevices.Add(new DeviceDtlWithResultModel()
                        {
                            RecordId = sch.record_id,
                            DeviceId = deviceMsg.device_id,
                            DeviceNo = deviceMsg.device_no,
                            DeviceName = deviceMsg.device_name,
                            DeviceKindName = deviceKindName,
                            ProjectName = projectName,
                            SchemeName = sch.scheme_name,
                            SchemeId = schId,
                            StartTestTime = sch.start_test_time.Value,
                            TestResult = testResult
                        });
                    }

                }

            }
            conditionDevices = conditionDevices.OrderBy(x => x.DeviceId).ToList();
            Getpage();
        }
        /// <summary>
        /// 获取页面
        /// </summary>
        private void Getpage()
        {
            CurrentPage = 1;
            TotalCount = conditionDevices.Count;
            CurrentPageChanged();


        }
        /// <summary>
        /// 页面变化
        /// </summary>
        private void CurrentPageChanged()
        {

            DeviceResultItemList.Clear();

            foreach (var i in conditionDevices.Skip((CurrentPage - 1) * CountPerPage).Take(CountPerPage))
            {
                DeviceResultItemList.Add(i);
            }
        }
        private void GetPieSeriesDone()
        {
            PieSeriesCollectionDone.Clear();
           
            int tesNoDone = allSchCount-TotalCount;
           
            ChartValues<int> chartvalue = new ChartValues<int>();
            chartvalue.Add(TotalCount);
            ChartValues<int> noChartvalue = new ChartValues<int>();
            noChartvalue.Add(tesNoDone);

            PieSeries series = new PieSeries();
            series.DataLabels = true;
            series.Title = "已测试";
            series.Values = chartvalue;

            PieSeries series2 = new PieSeries();
            series2.DataLabels = true;
            series2.Title = "未测试";
            series2.Values = noChartvalue;
            PieSeriesCollectionDone.Add(series);
            PieSeriesCollectionDone.Add(series2);

        }
    

        private void GetPieSeriesPLC()
        {
            PieSeriesCollectionPLC.Clear();
            int succTest = allDeviceList.FindAll(x => x.TestResult == "通过").Count;
            int noSuccTest = allDeviceList.FindAll(x => x.TestResult == "不通过").Count;
            ChartValues<int> chartvalue = new ChartValues<int>();
            chartvalue.Add(succTest);

            ChartValues<int> nochartvalue = new ChartValues<int>();
            nochartvalue.Add(noSuccTest);
            PieSeries series = new PieSeries();
            series.DataLabels = true;
            series.Title = "通过率";
            series.Values = chartvalue;

            PieSeries series2 = new PieSeries();
            series2.DataLabels = true;
            series2.Title = "不通过率";
            series2.Values = nochartvalue;
            PieSeriesCollectionPLC.Add(series);
            PieSeriesCollectionPLC.Add(series2);

        }


        private void GetPieSeriesFail()
        {
            PieSeriesCollectionFail.Clear();
            int succTest = allDeviceList.FindAll(x => x.TestResult == "通过").Count;
            int noSuccTest = allDeviceList.FindAll(x => x.TestResult == "不通过").Count;
            ChartValues<int> chartvalue = new ChartValues<int>();
            chartvalue.Add(succTest);
            ChartValues<int> noChartvalue = new ChartValues<int>();
            noChartvalue.Add(noSuccTest);
         
            PieSeries series = new PieSeries();
            series.DataLabels = true;
            series.Title = "通过";
            series.Values = chartvalue;

            PieSeries series2 = new PieSeries();
            series2.DataLabels = true;
            series2.Title = "不通过";
            series2.Values = noChartvalue;
            PieSeriesCollectionFail.Add(series);
            PieSeriesCollectionFail.Add(series2);

        }


        private void GetPieSeriesEveryDay()
        {
            PieSeriesCollectionEveryday.Clear();
            int dayTest = allDeviceList.FindAll(x => x.StartTestTime.Date == DateTime.Now.Date).Count;
            ChartValues<int> chartvalue = new ChartValues<int>();
            chartvalue.Add(dayTest);
            PieSeries series = new PieSeries();
            series.DataLabels = true;
            series.Title = "测试数量";
            series.Values = chartvalue;

            PieSeriesCollectionEveryday.Add(series);
        }
        #region 数据绑定



        /// <summary>
        /// 图标数据
        /// </summary>
        private SeriesCollection pieSeriesCollectionDone;
        public SeriesCollection PieSeriesCollectionDone
        {
            get { return pieSeriesCollectionDone; }
            set { pieSeriesCollectionDone = value; RaisePropertyChanged(); }
        }

        private SeriesCollection pieSeriesCollectionPLC;
        public SeriesCollection PieSeriesCollectionPLC
        {
            get { return pieSeriesCollectionPLC; }
            set { pieSeriesCollectionPLC = value; RaisePropertyChanged(); }
        }

        private SeriesCollection pieSeriesCollectionEveryday;
        public SeriesCollection PieSeriesCollectionEveryday
        {
            get { return pieSeriesCollectionEveryday; }
            set { pieSeriesCollectionEveryday = value; RaisePropertyChanged(); }
        }

        private SeriesCollection pieSeriesCollectionFail;
        public SeriesCollection PieSeriesCollectionFail
        {
            get { return pieSeriesCollectionFail; }
            set { pieSeriesCollectionFail = value; RaisePropertyChanged(); }
        }
        /// <summary>
        /// 总条数
        /// </summary>
        private int totalCount;
        public int TotalCount
        {
            get { return totalCount; }
            set { totalCount = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }
        /// <summary>
        /// 每页数量
        /// </summary>
        private int countPerPage = 15;
        public int CountPerPage
        {
            get { return countPerPage; }
            set { countPerPage = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }
        /// <summary>
        /// 单前页
        /// </summary>
        private int currentPage = 1;
        public int CurrentPage
        {
            get { return currentPage; }
            set { currentPage = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }

        private ObservableCollection<DeviceDtlWithResultModel> deviceResultItemList = new ObservableCollection<DeviceDtlWithResultModel>();
        public ObservableCollection<DeviceDtlWithResultModel> DeviceResultItemList
        {
            get { return deviceResultItemList; }
            set { deviceResultItemList = value; RaisePropertyChanged(); }
        }
        #endregion
        #region 命令绑定
        public DelegateCommand OnLoadCommand { set; get; }
        #endregion
    }
}