Display_D_HP/TeamAAS-VM/ViewModels/Statistics/AssemblyRecordQueryViewModel.cs

using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;

namespace TeamAAS_VP.ViewModels.Statistics
{
    public class AssemblyRecordQueryViewModel : BindableBase
    {
        private readonly IProductService _productService;
        private readonly ISystemDatabaseService _systemDatabaseService;

        public AssemblyRecordQueryViewModel(IProductService productService, ISystemDatabaseService systemDatabaseService)
        {
            _productService = productService;
            _systemDatabaseService = systemDatabaseService;

            PageSize = 20;
            PageIndex = 1;

            SearchCommand = new DelegateCommand(async () => await ExecuteSearchCommand(), CanSearch).ObservesProperty(() => SelectedProduct).ObservesProperty(() => StartDate).ObservesProperty(() => EndDate).ObservesProperty(() => IsSearching);
            PrevPageCommand = new DelegateCommand(async () => { if (PageIndex > 1) { PageIndex--; await ExecuteSearchCommand(); } }).ObservesProperty(() => PageIndex);
            NextPageCommand = new DelegateCommand(async () => { if (PageIndex * PageSize < TotalCount) { PageIndex++; await ExecuteSearchCommand(); } }).ObservesProperty(() => PageIndex).ObservesProperty(() => TotalCount);
            ExportCommand = new DelegateCommand(async () => await ExecuteExportCommand(), CanExport).ObservesProperty(() => Results).ObservesProperty(() => IsSearching);

            AllProduct = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
            StartDate = DateTime.Now.Date;
            EndDate = DateTime.Now.Date.AddDays(1);
        }

        #region Properties
        private ObservableCollection<ProductModel> _AllProduct;
        public ObservableCollection<ProductModel> AllProduct
        {
            get { return _AllProduct; }
            set { SetProperty(ref _AllProduct, value); }
        }

        private ProductModel _SelectedProduct;
        public ProductModel SelectedProduct
        {
            get { return _SelectedProduct; }
            set { SetProperty(ref _SelectedProduct, value); }
        }

        private DateTime? _StartDate;
        public DateTime? StartDate
        {
            get { return _StartDate; }
            set { SetProperty(ref _StartDate, value); }
        }

        private DateTime? _EndDate;
        public DateTime? EndDate
        {
            get { return _EndDate; }
            set { SetProperty(ref _EndDate, value); }
        }

        private string _ProductNumber;
        public string ProductNumber
        {
            get { return _ProductNumber; }
            set { SetProperty(ref _ProductNumber, value); }
        }

        private ObservableCollection<AssemblyRecord> _Results = new ObservableCollection<AssemblyRecord>();
        public ObservableCollection<AssemblyRecord> Results
        {
            get { return _Results; }
            set { SetProperty(ref _Results, value); }
        }

        private int _PageIndex;
        public int PageIndex
        {
            get { return _PageIndex; }
            set { SetProperty(ref _PageIndex, value); }
        }

        private int _PageSize;
        public int PageSize
        {
            get { return _PageSize; }
            set { SetProperty(ref _PageSize, value); }
        }

        private int _TotalCount;
        public int TotalCount
        {
            get { return _TotalCount; }
            set { SetProperty(ref _TotalCount, value); }
        }

        private bool _IsSearching = false;
        public bool IsSearching
        {
            get { return _IsSearching; }
            set { SetProperty(ref _IsSearching, value); }
        }
        #endregion

        #region Commands
        public DelegateCommand SearchCommand { get; private set; }
        public DelegateCommand PrevPageCommand { get; private set; }
        public DelegateCommand NextPageCommand { get; private set; }
        public DelegateCommand ExportCommand { get; private set; }
        #endregion

        private bool CanSearch()
        {
            if (IsSearching) return false;
            if (SelectedProduct == null && string.IsNullOrWhiteSpace(ProductNumber))
                return false;
            if (!StartDate.HasValue || !EndDate.HasValue) return false;
            return true;
        }

        private bool CanExport()
        {
            // allow export even if current page is empty; user may want to export all matching records
            return !IsSearching && StartDate.HasValue && EndDate.HasValue && (SelectedProduct != null || !string.IsNullOrWhiteSpace(ProductNumber));
        }

        private async Task ExecuteSearchCommand()
        {
            try
            {
                IsSearching = true;

                // determine time range (use full days)
                var start = StartDate.HasValue ? StartDate.Value.Date : DateTime.MinValue;
                var end = EndDate.HasValue ? EndDate.Value.Date.AddDays(1) : DateTime.MaxValue;

                string productNumberFilter = null;
                if (!string.IsNullOrWhiteSpace(ProductNumber)) productNumberFilter = ProductNumber.Trim();
                // if SelectedProduct is selected, use its Name as productNumber? The user requested select product name then time range; productNumber precise search should still be supported
                if (SelectedProduct != null && string.IsNullOrEmpty(productNumberFilter))
                {
                    // assume SelectedProduct.Name correspond to ProductNumber field used when storing
                    productNumberFilter = SelectedProduct.Name;
                }

                int pageIndex = PageIndex < 1 ? 1 : PageIndex;
                int pageSize = PageSize < 1 ? 20 : PageSize;

                var res = await _systemDatabaseService.QueryAssemblyRecordsPagedAsync(productNumberFilter,ProductNumber, start, end, pageIndex, pageSize);
                Results = new ObservableCollection<AssemblyRecord>(res.Items);
                TotalCount = res.TotalCount;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, Lang.错误, MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                IsSearching = false;
            }
        }

        private async Task ExecuteExportCommand()
        {
            try
            {
                IsSearching = true;

                // determine time range
                var start = StartDate.HasValue ? StartDate.Value.Date : DateTime.MinValue;
                var end = EndDate.HasValue ? EndDate.Value.Date.AddDays(1) : DateTime.MaxValue;

                string productNumberFilter = null;
                if (!string.IsNullOrWhiteSpace(ProductNumber)) productNumberFilter = ProductNumber.Trim();
                if (SelectedProduct != null && string.IsNullOrEmpty(productNumberFilter))
                {
                    productNumberFilter = SelectedProduct.Name;
                }

                // fetch all matching records (not paged)
                var all = await _systemDatabaseService.QueryAssemblyRecordsAsync(productNumberFilter, ProductNumber, start, end);
                if (all == null || !all.Any())
                {
                    MessageBox.Show(Lang.没有找到符合条件的记录, Lang.提示, MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }

                var saveFileDialog = new Microsoft.Win32.SaveFileDialog
                {
                    FileName = $"AssemblyRecords_{DateTime.Now.ToString("yyyyMMddHHmmss")}.csv",
                    DefaultExt = ".csv",
                    Filter = "CSV Files (*.csv)|*.csv"
                };
                var result = saveFileDialog.ShowDialog();
                if (result != true) return;
                var path = saveFileDialog.FileName;

                // write in streaming manner to support large sets
                using (var sw = new StreamWriter(path, false, Encoding.UTF8))
                {
                    // header matches AssemblyRecord properties shown in the UI, include all coordinate fields
                    sw.WriteLine("Id,Timestamp,RecipeName,ProductSN,PartSN,Success,AssemblyPressure,AssemblyDurationSeconds,DownCameraCoord1,DownCameraCoord2,DownCameraCoord3,DownCameraCoord4,PickMoveCameraCoord,PlaceMoveCameraCoord1,PlaceMoveCameraCoord2,PlaceMoveCameraCoord3,PlaceMoveCameraCoord4,PlaceActualCoord,DeviceName,DeviceId,OperatorName,Remark");
                    foreach (var r in all)
                    {
                        var line = string.Join(",",
                            EscapeCsv(r.Id.ToString()),
                            EscapeCsv(r.Timestamp.ToString("yyyy-MM-dd HH:mm:ss")),
                            EscapeCsv(r.RecipeName),
                            EscapeCsv(r.ProductSN),
                            EscapeCsv(r.PartSN),
                            EscapeCsv(r.Success ? "1" : "0"),
                            EscapeCsv(r.AssemblyPressure.ToString()),
                            EscapeCsv(r.AssemblyDurationSeconds.ToString()),
                            EscapeCsv(r.DownCameraCoord1),
                            EscapeCsv(r.DownCameraCoord2),
                            EscapeCsv(r.DownCameraCoord3),
                            EscapeCsv(r.DownCameraCoord4),
                            EscapeCsv(r.PickMoveCameraCoord),
                            EscapeCsv(r.PlaceMoveCameraCoord1),
                            EscapeCsv(r.PlaceMoveCameraCoord2),
                            EscapeCsv(r.PlaceMoveCameraCoord3),
                            EscapeCsv(r.PlaceMoveCameraCoord4),
                            EscapeCsv(r.PlaceActualCoord),
                            EscapeCsv(r.DeviceName),
                            EscapeCsv(r.DeviceId.ToString()),
                            EscapeCsv(r.OperatorName),
                            EscapeCsv(r.Remark)
                        );
                        sw.WriteLine(line);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, Lang.错误, MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                IsSearching = false;
            }
            await Task.CompletedTask;
        }

        private string EscapeCsv(string s)
        {
            if (s == null) return "";
            if (s.Contains(",") || s.Contains("\"") || s.Contains("\r") || s.Contains("\n"))
            {
                return "\"" + s.Replace("\"", "\"\"") + "\"";
            }
            return s;
        }
    }
}