HKC/DM_Weight/ViewModels/SurgeryTakeDialogViewModel.cs

using DM_Weight.Models;
using DM_Weight.msg;
using DM_Weight.Port;
using DM_Weight.select;
using DM_Weight.util;
using log4net;
using MaterialDesignThemes.Wpf;
using Newtonsoft.Json.Linq;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Windows.Media;

namespace DM_Weight.ViewModels
{
    public class SurgeryTakeDialogViewModel : BindableBase, IDialogAware, IRegionMemberLifetime
    {
        private static readonly DateTime Jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        private readonly ILog logger = LogManager.GetLogger(typeof(OrderTakeDialogViewModel));
        public string Title => "手术核销";

        private SurgicalSchedule _surgicalSchedule;
        public SurgicalSchedule _SurgicalSchedule { get => _surgicalSchedule; set => SetProperty(ref _surgicalSchedule, value); }

        private List<MachineRecord> machineRecordList;
        public List<MachineRecord> MachineRecordList { get => machineRecordList; set => SetProperty(ref machineRecordList, value); }


        private string? _searchValue;

        /// <summary>
        /// 查询条件 查询字段值
        /// </summary>
        public string? SearchValue
        {
            get { return _searchValue; }
            set
            {
                SetProperty(ref _searchValue, value);
                RequestData();
            }
        }

        public static List<OrderTakeSelect> StaticSelects = new()
        {
            new OrderTakeSelect
            {
                Code = "DrugName",
                Name = "药品名称"
            },
            new OrderTakeSelect
            {
                Code = "PyCode",
                Name = "拼音码"
            },
            new OrderTakeSelect
            {
                Code = "DrugBarcode",
                Name = "药品条码"
            },
            new OrderTakeSelect
            {
                Code = "DrugId",
                Name = "药品编码"
            }
        };


        private List<OrderTakeSelect> _selects = StaticSelects;

        public List<OrderTakeSelect> Selects
        {
            get { return _selects; }
            set
            {
                SetProperty(ref _selects, value);
            }
        }

        private int _totalCount = 0;
        public int TotalCount { get => _totalCount; set => SetProperty(ref _totalCount, value); }

        private int _pageNum = 1;
        public int PageNum
        {
            get => _pageNum;
            set
            {
                SetProperty(ref _pageNum, value);
                RequestData();
            }
        }

        private int _pageCount = 1;
        public int PageCount
        {
            get => _pageCount;
            set
            {
                SetProperty(ref _pageCount, value);
            }
        }

        private int _pageSize = 9;
        public int PageSize
        {
            get => _pageSize;
            set
            {
                SetProperty(ref _pageSize, value);
            }
        }

        private int _status = 0;

        public int Status
        {
            get => _status; set => SetProperty(ref _status, value);
        }

        private SolidColorBrush _colorBrush;

        public SolidColorBrush SnackbarBackground
        {
            get => _colorBrush;
            set => SetProperty(ref _colorBrush, value);
        }
        private ISnackbarMessageQueue _snackbarMessageQueue = new SnackbarMessageQueue(TimeSpan.FromSeconds(3));

        public ISnackbarMessageQueue SnackbarMessageQueue
        {
            get => _snackbarMessageQueue;
            set => SetProperty(ref _snackbarMessageQueue, value);
        }

        List<ChannelStock> ReturnStockLst;

        private IEnumerable<IGrouping<int, ChannelStock>> enumerable;
        private IEnumerator<IGrouping<int, ChannelStock>> enumerator;

        private OrderTakeSelect _selectedItem = StaticSelects[0];
        /// <summary>
        /// 查询条件 查询字段
        /// </summary>
        public OrderTakeSelect SelectedItem
        {
            get { return _selectedItem; }
            set
            {
                SetProperty(ref _selectedItem, value);
                RequestData();
            }
        }

        private MachineRecord selectedRecord;
        public MachineRecord SelectedRecord { get => selectedRecord; set => SetProperty(ref selectedRecord, value); }

        private PortUtil _portUtil;
        IEventAggregator _eventAggregator;
        IDialogService _dialogService;
        public SurgeryTakeDialogViewModel(PortUtil portUtil, IEventAggregator eventAggregator, IDialogService DialogService)
        {
            _dialogService = DialogService;
            _portUtil = portUtil;
            _eventAggregator = eventAggregator;
        }

        public bool KeepAlive => false;

        public event Action<IDialogResult> RequestClose;

        public bool CanCloseDialog()
        {
            return Status == 0;
        }

        public void OnDialogClosed()
        {
            // 取消消息订阅
            _eventAggregator.GetEvent<PortUtilEvent>().Unsubscribe(DoMyPrismEvent);
        }

        public void OnDialogOpened(IDialogParameters parameters)
        {
            _eventAggregator.GetEvent<PortUtilEvent>().Subscribe(DoMyPrismEvent);
            SurgicalSchedule ss = parameters.GetValue<SurgicalSchedule>("SurgeryInfo");
            _SurgicalSchedule = ss;
            RequestData();
        }
        public async void RequestData()
        {
            int totalCount = 0;
            MachineRecordList = SqlSugarHelper.Db.Queryable<MachineRecord>()
                .Includes<DrugInfo>(mr => mr.DrugInfo)
                .Includes<UserList>(mr => mr.User)
                .Includes<SurgicalScheduleDetail>(mr => mr._SurgicalScheduleDetailLst)
                .Where(mr => mr.Type == 2)
                .Where(mr => mr.Status < 2)
                .Where(mr => mr.MachineId.Equals(ConfigurationManager.AppSettings["machineId"] ?? "DM3"))
                //.WhereIF(QueryDate != null, mr => mr.OperationTime.ToString("yyyy-MM-dd") == QueryDate)
                .WhereIF(!String.IsNullOrEmpty(SearchValue) && SelectedItem.Code.Equals("DrugId"), (mr) => mr.DrugInfo.DrugId.ToString().Contains(SearchValue))
                .WhereIF(!String.IsNullOrEmpty(SearchValue) && SelectedItem.Code.Equals("DrugName"), (mr) => mr.DrugInfo.DrugName.Contains(SearchValue))
                .WhereIF(!String.IsNullOrEmpty(SearchValue) && SelectedItem.Code.Equals("PyCode"), (mr) => mr.DrugInfo.PyCode.Contains(SearchValue))
                .WhereIF(!String.IsNullOrEmpty(SearchValue) && SelectedItem.Code.Equals("DrugBarcode"), (mr) => mr.DrugInfo.DrugBarcode.Contains(SearchValue))
                .OrderBy(mr => mr.OperationTime)
               .ToPageList(PageNum, PageSize, ref totalCount);

            MachineRecordList.ForEach(mr => mr.HasCheckNum = mr._SurgicalScheduleDetailLst.Sum(sd => sd.Quantity));
            TotalCount = totalCount;
        }

        public DelegateCommand BtnCloseCommand
        {
            get => new DelegateCommand(() =>
            {
                // 关闭当前窗口
                RequestClose?.Invoke(new DialogResult(ButtonResult.Cancel));
            });
        }

        /// <summary>
        /// 选中行事件
        /// </summary>
        public DelegateCommand RowSelected
        {
            get => new DelegateCommand(() =>
            {
                if (SelectedRecord != null && selectedRecord.Id != null)
                {
                    MachineRecordList = MachineRecordList.Select(x =>
                    {
                        if (x.Id == SelectedRecord.Id)
                        {
                            x.IsSelected = !x.IsSelected;
                            if (x.IsSelected)
                            {
                                if (SelectedRecord._SurgicalScheduleDetailLst != null && SelectedRecord._SurgicalScheduleDetailLst.Count > 0)
                                {
                                    //已经核销数
                                    int HasCheckNum = SelectedRecord._SurgicalScheduleDetailLst.Sum(sd => sd.Quantity);
                                    x.CheckQuantity = SelectedRecord.Quantity - HasCheckNum;
                                    x.ReturnQuantity1 = SelectedRecord.Quantity - HasCheckNum - x.CheckQuantity;
                                    x.ReturnQuantity2 = HasCheckNum + x.CheckQuantity;
                                }
                                else
                                {
                                    x.CheckQuantity = SelectedRecord.Quantity;
                                    x.ReturnQuantity1 = 0;
                                    x.ReturnQuantity2 = SelectedRecord.Quantity;
                                }
                            }
                            else
                            {
                                x.CheckQuantity = 0;
                                x.ReturnQuantity1 = 0;
                                x.ReturnQuantity2 = 0;
                            }
                        }
                        return x;
                    }).ToList();


                }
            });
        }

        /// <summary>
        /// 确认核销
        /// </summary>
        public DelegateCommand AddSurgeryCommand
        {
            get => new DelegateCommand(() =>
            {
                List<MachineRecord> RecordsLst = MachineRecordList.FindAll(rl => rl.IsSelected && rl.CheckQuantity > 0).ToList();
                if (_SurgicalSchedule != null && RecordsLst.Count > 0)
                {
                    string operationId = _SurgicalSchedule.OperationId;
                    var f = SqlSugarHelper.Db.UseTran(() =>
                    {
                        SqlSugarHelper.Db.Updateable(new SurgicalSchedule()
                        {
                            DmStatus = 1,
                            Id = _SurgicalSchedule.Id
                        }).UpdateColumns(it => new { it.DmStatus }).WhereColumns(it => new { it.Id }).ExecuteCommand();
                        for (int i = 0; i < RecordsLst.Count; i++)
                        {
                            SqlSugarHelper.Db.Insertable(new SurgicalScheduleDetail()
                            {
                                OperationId = operationId,
                                GetRecordId = RecordsLst[i].Id,
                                Quantity = RecordsLst[i].CheckQuantity,
                                DrugId = RecordsLst[i].DrugId,
                                ManuNo = RecordsLst[i].ManuNo,
                                EffDate = RecordsLst[i].EffDate.ToString(),
                                InsertUserId = HomeWindowViewModel.Operator?.Id,
                            }).ExecuteCommand();

                            int hasQuantity = RecordsLst[i]._SurgicalScheduleDetailLst.Sum(sd => sd.Quantity);
                            int dmStatus = 0;
                            //已经全部挂上钩,修改dm_machine_record状态为完成
                            //if (hasQuantity + RecordsLst[i].CheckQuantity == RecordsLst[i].Quantity)
                            //{
                            //    dmStatus = 2;
                            //}
                            //else
                            {
                                dmStatus = 1;
                            }
                            SqlSugarHelper.Db.Updateable(new MachineRecord()
                            {
                                Status = dmStatus,
                                Id = RecordsLst[i].Id
                            }).UpdateColumns(it => new { it.Status }).WhereColumns(it => new { it.Id }).ExecuteCommand();


                        }
                    });
                    if (f.IsSuccess)
                    {
                        AlertMsg alertMsg = new AlertMsg
                        {
                            Message = "核销完成",
                            Type = MsgType.SUCCESS,
                        };
                        _eventAggregator.GetEvent<SnackbarEvent>().Publish(alertMsg);
                        RequestData();

                    }
                    else
                    {
                        logger.Info($"核销异常");

                        SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#b71c1c"));
                        SnackbarMessageQueue.Enqueue("核销异常！");
                    }
                }
                else
                {

                    SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#b71c1c"));
                    SnackbarMessageQueue.Enqueue("未选中数据，或选中数据核销数量为0");
                }
            });
        }
        /// <summary>
        /// 全部归还（还药、还空瓶）
        /// </summary>
        public DelegateCommand ReturnCommand
        {
            get => new DelegateCommand(() =>
            {
                List<MachineRecord> RecordsLst = MachineRecordList.FindAll(rl => rl.IsSelected && rl.CheckQuantity == 0).ToList();
                ReturnStockLst = new List<ChannelStock>();
                if (RecordsLst.Count > 0)
                {

                    //待还药的记录
                    List<MachineRecord> ReturnDrugLst = RecordsLst.Where(rl => rl.ReturnQuantity1 > 0).ToList();
                    //待还空瓶的记录
                    List<MachineRecord> ReturnEmptyLst = RecordsLst.Where(rl => rl.ReturnQuantity2 > 0).ToList();


                    for (int i = 0; i < ReturnDrugLst.Count; i++)
                    {
                        ChannelStock queryData = SqlSugarHelper.Db.Queryable<ChannelStock>()
                                               .Includes<DrugInfo>(cs => cs.DrugInfo)
                                               .Where(cs => cs.DrugId == ReturnDrugLst[i].DrugId)
                                               .Where(cs => cs.MachineId.Equals(ConfigurationManager.AppSettings["machineId"] ?? "DM3"))
                                               .Where(cs => cs.ManuNo == ReturnDrugLst[i].ManuNo)
                                               .OrderBy(cs => cs.Quantity).First();
                        if (queryData != null)
                        {
                            queryData.AddQuantity = ReturnDrugLst[i].ReturnQuantity1;
                            queryData.MachineRecordId = ReturnDrugLst[i].Id;
                            ReturnStockLst.Add(queryData);
                        }
                    }
                    for (int j = 0; j < ReturnEmptyLst.Count; j++)
                    {
                        ChannelStock queryData = SqlSugarHelper.Db.Queryable<ChannelStock>()
                                              .Includes<DrugInfo>(cs => cs.DrugInfo)
                                              .Where(cs => cs.DrugId == ReturnEmptyLst[j].DrugId)
                                              .Where(cs => cs.MachineId.Equals(ConfigurationManager.AppSettings["machineId"] ?? "DM3"))
                                              //.Where(cs => cs.ManuNo == ReturnEmptyLst[j].ManuNo)
                                              .Where(cs => cs.DrawerType == 2)
                                              .OrderBy(cs => cs.Quantity).First();
                        if (queryData != null)
                        {
                            queryData.ReturnQuantity = ReturnEmptyLst[j].ReturnQuantity2;
                            queryData.MachineRecordId = ReturnEmptyLst[j].Id;
                            ReturnStockLst.Add(queryData);
                        }
                    }
                    if (ReturnStockLst != null && ReturnStockLst.Count > 0)
                    {
                        ReturnStockLst = ReturnStockLst.OrderBy(cls => cls.DrawerNo).ToList();
                        //还药时AddQuantity有值；还空瓶时ReturnQuantity有值
                        enumerable = ReturnStockLst.GroupBy(cs => cs.DrawerNo, cs => cs);
                        enumerator = enumerable.GetEnumerator();
                        enumerator.MoveNext();
                        Status = 1;
                        OpenOneByOne();
                    }
                    else
                    {

                        SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#b71c1c"));
                        SnackbarMessageQueue.Enqueue("选中数据未绑定库位，请先进行绑定库位");
                    }
                }
                else
                {
                    SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#b71c1c"));
                    SnackbarMessageQueue.Enqueue("未选中数据，或选中数据核销数量不为0");
                }
            });
        }
        /// <summary>
        /// 刷新
        /// </summary>
        public DelegateCommand QueryCommand
        {
            get => new DelegateCommand(() =>
            {
                RequestData();
            });
        }
        void DoMyPrismEvent(DeviceMsg msg)
        {

            if (msg.WindowName == "SurgeryTakeWindow")
            {
                IGrouping<int, ChannelStock> grouping = enumerator.Current;
                int DrawerNo = grouping.Key;
                List<ChannelStock> channelStocks = grouping.ToList();

                switch (msg.EventType)
                {
                    // 抽屉打开
                    case EventType.DRAWEROPEN:
                        if (Status == 1)
                        {
                            if (channelStocks[0].process == 1)
                            {
                                channelStocks.ForEach(it => it.process = 2);
                            }
                        }

                        break;
                    // 抽屉关闭
                    case EventType.DRAWERCLOSE:
                        if (Status == 1)
                        {
                            if (channelStocks[0].process == 2)
                            {
                                channelStocks.ForEach(it => it.process = 3);
                            }
                            IGrouping<int, ChannelStock> groupingBefore = enumerator.Current;
                            int DrawerNoBefore = groupingBefore.Key;
                            if (enumerator.MoveNext())
                            {
                                IGrouping<int, ChannelStock> groupingAfter = enumerator.Current;
                                int DrawerNoAfter = groupingAfter.Key;
                                if (DrawerNoBefore < 9 && DrawerNoAfter > 8)
                                {
                                    Thread.Sleep(50);
                                }
                                OpenOneByOne();
                            }
                            // 已经全部取出
                            else
                            {
                                Status = 3;

                                //保存数据

                                //TakeFinish();
                            }
                        }
                        break;
                    // 数量变化
                    case EventType.UPDATEQUANTITY:
                        if (Status == 1)
                        {
                            logger.Info($"抽屉【{DrawerNo}】库位取药数量【{msg.Quantitys}】");
                        }
                        break;
                    // 打开失败
                    case EventType.OPENERROR:
                        AlertMsg alertMsg = new AlertMsg
                        {
                            Message = msg.Message,
                            Type = MsgType.ERROR,
                        };
                        _eventAggregator.GetEvent<SnackbarEvent>().Publish(alertMsg);
                        Status = 0;
                        break;
                }
            }

        }

        private void OpenOneByOne()
        {
            IGrouping<int, ChannelStock> grouping = enumerator.Current;
            int DrawerNo = grouping.Key;
            List<ChannelStock> channelStocks = grouping.ToList();
            channelStocks.ForEach(it => it.process = 1);

            IEnumerable<string> strDrugName = channelStocks.Select(cs => cs.DrugInfo.DrugName);
            string strNames = string.Empty;
            foreach (string name in strDrugName)
            {
                strNames += name;
            }


             

            int drugQuantity = channelStocks.Sum(cs => cs.AddQuantity);

            int emptyQuantity = channelStocks.Sum(cs => cs.ReturnQuantity);
            string speakTxt = $"正在打开{DrawerNo}号抽屉,请将{strNames}的";
            if (drugQuantity > 0)
            {
                speakTxt += $"共计{drugQuantity}个药放入抽屉！";
            }
            if (emptyQuantity > 0)
            {
                speakTxt += $"共计{emptyQuantity}个空瓶放入抽屉！";
            }
            _portUtil.SpeakAsync(speakTxt);

            //List<ChannelStock> singleChannels = channelStocks.FindAll(it => it.BoardType != 1);

            // 发送取药数量
            //singleChannels.ForEach(it =>
            //{
            //    try
            //    {

            //        _portUtil.TakeQuantity(DrawerNo, it.ColNo, it.TakeQuantity, it.Quantity - it.TakeQuantity);
            //    }
            //    catch (Exception ex)
            //    {
            //        AlertMsg alertMsg = new AlertMsg
            //        {
            //            Message = $"打开抽屉异常{ex.Message}",
            //            Type = MsgType.ERROR,
            //        };
            //        _eventAggregator.GetEvent<SnackbarEvent>().Publish(alertMsg);
            //    }
            //});

            _portUtil.WindowName = "SurgeryTakeWindow";
            _portUtil.BoardType = channelStocks.Count > 0 ? channelStocks[0].BoardType : 1;
            _portUtil.ColNos = channelStocks.Select(it => it.ColNo).ToArray();
            _portUtil.DrawerNo = DrawerNo;
            _portUtil.Start();
        }


        private bool _isFinishClick = false;

        public bool IsFinishClick { get => _isFinishClick; set => SetProperty(ref _isFinishClick, value); }
        //完成
        private void TakeFinish()
        {
            IsFinishClick = true;
            bool bRet = false;
            var f = SqlSugarHelper.Db.UseTran(() =>
            {
                for (int i = 0; i < ReturnStockLst.Count; i++)
                {
                    ChannelStock it = ReturnStockLst[i];
                    int quantity = 0;
                    if (it.AddQuantity > 0)  //还药
                    {
                        quantity = it.AddQuantity;
                        bRet = ReturnDrug(it);

                    }
                    else
                    {
                        quantity = it.ReturnQuantity;
                        bRet = ReturnEmpty(it);
                    }
                    if (!bRet)
                    {
                        break;
                    }
                    // 更新屏显库存
                    if (it.BoardType == 5)
                    {
                        _portUtil.WriteQuantity(it.DrawerNo, it.ColNo, it.Quantity + quantity);
                    }


                    SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#00e676"));
                    SnackbarMessageQueue.Enqueue("操作完成，库存已更新！");
                }
                return bRet;
            });
            if (!f.IsSuccess || !f.Data)
            {
                SnackbarBackground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#b71c1c"));
                SnackbarMessageQueue.Enqueue("库存更新失败！");
            }
            Status = 0;
            IsFinishClick = false;
            RequestClose?.Invoke(new DialogResult(ButtonResult.OK));
        }
        /// <summary>
        /// 还药
        /// </summary>
        private bool ReturnDrug(ChannelStock stock)
        {
            try
            {
                var f = SqlSugarHelper.Db.UseTran(() =>
                {
                    string InvoiceId = "RETURN_" + CurrentTimeMillis(); 
                    MachineRecord recordInfo = SqlSugarHelper.Db.Queryable<MachineRecord>().Where(rd => rd.Id == stock.MachineRecordId).First();
                    // 更新数据 库存信息
                    SqlSugarHelper.Db.Updateable(new ChannelStock()
                    {
                        Quantity = stock.Quantity + stock.AddQuantity,
                        Id = stock.Id,
                    }).UpdateColumns(it => new { it.Quantity }).ExecuteCommand();
                    // 获取更新完库存后的药品库存
                    List<ChannelStock> nowChannels = SqlSugarHelper.Db.Queryable<ChannelStock>()
                        .Where(cs => cs.MachineId.Equals(stock.MachineId))
                        .Where(cs => cs.DrugId.Equals(stock.DrugId))
                        .Where(cs => cs.DrawerType == 1)
                        .ToList();
                    // 更新数据 取药记录 设置还药数量、状态 
                    SqlSugarHelper.Db.Updateable(new MachineRecord()
                    {
                        ReturnQuantity1 = recordInfo.ReturnQuantity1 + stock.AddQuantity,
                        Id = recordInfo.Id,
                        Status = (recordInfo.CanReturnQuantity - stock.AddQuantity) == 0 ? 2 : 1,
                    }).UpdateColumns(it => new { it.ReturnQuantity1, it.Status }).ExecuteCommand();

                    // 保存数据 还药记录
                    SqlSugarHelper.Db.Insertable(new MachineRecord()
                    {
                        MachineId = stock.MachineId,
                        DrawerNo = stock.DrawerNo,
                        ColNo = stock.ColNo,
                        DrugId = stock.DrugId,
                        ManuNo = stock.ManuNo,
                        EffDate = !String.IsNullOrEmpty(stock.EffDate) ? DateTime.ParseExact(stock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                        Operator = HomeWindowViewModel.Operator?.Id,
                        OperationTime = DateTime.Now,
                        Quantity = stock.AddQuantity,
                        Type = 31,
                        InvoiceId = InvoiceId,
                        GetId = stock.MachineRecordId
                        //,StockQuantity = nowChannels.Sum(it => it.Quantity)
                    }).ExecuteCommand();

                    //保存账册
                    SqlSugarHelper.Db.Insertable(new AccountBookG2()
                    {
                        DrugId = stock.DrugId,
                        Type = 1,
                        Department = ConfigurationManager.AppSettings["department"].ToString(),
                        InvoiceNo = InvoiceId,
                        ManuNo = stock.ManuNo,
                        EffDate = stock.EffDate,
                        AddQuantity = stock.AddQuantity,
                        UserId1 = HomeWindowViewModel.Operator?.Id,
                        UserId2 = HomeWindowViewModel.Reviewer?.Id,
                        MachineId = ConfigurationManager.AppSettings["machineId"].ToString(),
                        CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                        CreateTime = DateTime.Now

                    }).ExecuteCommand();
                    //修改凌晨生成的日结存数据
                    AccountBookG2 accountBookG2Day = SqlSugarHelper.Db.Queryable<AccountBookG2>()
                    .Where(ab => ab.MachineId.Equals(stock.MachineId))
                    .Where(ab => ab.Type == 3)
                    .Where(ab => ab.DrugId == stock.DrugId)
                    .Where(ab => ab.ManuNo == stock.ManuNo)
                    .Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
                    if (accountBookG2Day != null)
                    {
                        accountBookG2Day.ManuStock = accountBookG2Day.ManuStock + stock.AddQuantity;
                        SqlSugarHelper.Db.Updateable(accountBookG2Day).ExecuteCommand();
                    }
                    else
                    {
                        //生成日结存时可能没有该库位的绑定信息，需要写入日结存
                        int iDayResult = SqlSugarHelper.Db.Insertable(new AccountBookG2()
                        {
                            DrugId = stock.DrugId,
                            Type = 3,
                            ManuNo = stock.ManuNo,
                            EffDate = stock.EffDate,
                            YQuantity = 0,
                            ManuStock = stock.ReturnQuantity,
                            TotalStock = stock.ReturnQuantity,
                            UserId1 = HomeWindowViewModel.Operator?.Id,
                            UserId2 = HomeWindowViewModel.Reviewer?.Id,
                            MachineId = ConfigurationManager.AppSettings["machineId"].ToString(),
                            CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                            InvoiceNo = "日结存"
                        }).ExecuteCommand();
                        if (iDayResult <= 0)
                        {
                            logger.Info($"未写入日结存数据{stock.DrugId}-{stock.ManuNo}-{stock.EffDate}-{stock.AddQuantity}");
                        }
                    }
                    //修改凌晨生成的总结存数据
                    AccountBookG2 accountBookG2Total = SqlSugarHelper.Db.Queryable<AccountBookG2>()
                    .Where(ab => ab.MachineId.Equals(stock.MachineId))
                    .Where(ab => ab.Type == 4)
                    .Where(ab => ab.DrugId == stock.DrugId)
                    .Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
                    if (accountBookG2Total != null)
                    {
                        accountBookG2Total.TotalStock = accountBookG2Total.TotalStock + stock.AddQuantity;
                        SqlSugarHelper.Db.Updateable(accountBookG2Total).ExecuteCommand();
                    }
                    else
                    {
                        //生成总结存时可能没有该库位的绑定信息，需要写入总结存
                        int iTotalResult = SqlSugarHelper.Db.Insertable(new AccountBookG2()
                        {
                            DrugId = stock.DrugId,
                            Type = 4,
                            YQuantity = 0,
                            ManuStock = stock.ReturnQuantity,
                            TotalStock = stock.ReturnQuantity,
                            UserId1 = HomeWindowViewModel.Operator?.Id,
                            UserId2 = HomeWindowViewModel.Reviewer?.Id,
                            MachineId = ConfigurationManager.AppSettings["machineId"].ToString(),
                            CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                            InvoiceNo = "总结存"
                        }).ExecuteCommand();
                        if (iTotalResult <= 0)
                        {
                            logger.Info($"未写入总结存数据{stock.DrugId}-{stock.AddQuantity}");
                        }
                    }
                });
                if (f.IsSuccess)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception)
            {

                throw;
            }
        }
        /// <summary>
        /// 还空瓶
        /// </summary>
        private bool ReturnEmpty(ChannelStock stock)
        {
            string InvoiceId = "RETURN_" + CurrentTimeMillis();
            var f = SqlSugarHelper.Db.UseTran(() =>
            {

                // 更新数据 库存信息
                SqlSugarHelper.Db.Updateable(new ChannelStock()
                {
                    Quantity = stock.Quantity + stock.ReturnQuantity,
                    Id = stock.Id,
                }).UpdateColumns(it => new { it.Quantity }).ExecuteCommand();

                // 获取更新完库存后的药品库存
                List<ChannelStock> nowChannels = SqlSugarHelper.Db.Queryable<ChannelStock>()
                    .Where(cs => cs.MachineId.Equals(stock.MachineId))
                    .Where(cs => cs.DrugId.Equals(stock.DrugId))
                    .Where(cs => cs.DrawerType == 1)
                    .ToList();

                MachineRecord recordInfo = SqlSugarHelper.Db.Queryable<MachineRecord>().Where(rd => rd.Id == stock.MachineRecordId).First();

                // 更新数据 取药记录 设置还药数量、状态
                SqlSugarHelper.Db.Updateable(new MachineRecord()
                {
                    ReturnQuantity2 = stock.ReturnQuantity,
                    Id = recordInfo.Id,
                    Status = 2,
                }).UpdateColumns(it => new { it.ReturnQuantity2, it.Status }).ExecuteCommand();

                // 保存数据 还药空瓶记录
                SqlSugarHelper.Db.Insertable(new MachineRecord()
                {
                    MachineId = stock.MachineId,
                    DrawerNo = stock.DrawerNo,
                    ColNo = stock.ColNo,
                    DrugId = stock.DrugId,
                    ManuNo = stock.ManuNo,
                    EffDate = !String.IsNullOrEmpty(stock.EffDate) ? DateTime.ParseExact(stock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                    Operator = HomeWindowViewModel.Operator?.Id,
                    Reviewer = HomeWindowViewModel.Reviewer?.Id,
                    OperationTime = DateTime.Now,
                    Quantity = stock.ReturnQuantity, //ReturnQuantity,
                    Type = 32,
                    InvoiceId = InvoiceId,
                    GetId = stock.MachineRecordId
                    //,StockQuantity = nowChannels.Sum(it => it.Quantity)
                }).ExecuteCommand();

                return true;
            });

            if (!f.IsSuccess || !f.Data)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public long CurrentTimeMillis()
        {
            return (long)(DateTime.UtcNow - Jan1st1970).TotalMilliseconds;
        }
        /// <summary>
        /// 取消
        /// </summary>
        public DelegateCommand CancleTake
        {
            get => new DelegateCommand(() =>
            {
                _portUtil.ResetData();
                Status = 0;
            });
        }
        // 完成按钮
        public DelegateCommand TakeFinishCommand
        {
            get => new DelegateCommand(TakeFinish);
        }
    }

}