using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using GroupLine.App.ModelDto;
using GroupLine.Com;
using GroupLine.Model.KanBan;
using NLog;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace GroupLine.App.ViewModel
{
    public class KanBanViewModel : ViewModelBase
    {
        //日志的实例化
        private static Logger _Logger = LogManager.GetCurrentClassLogger();

        //FSQL实例
        static IFreeSql Fsql;

        public KanBanViewModel()
        {
            try
            {

                //获取程序的配置信息
                var SqlCon = ConfigHelper.GetValue("connecting");

                Fsql = new FreeSql.FreeSqlBuilder()
                     .UseConnectionString(FreeSql.DataType.SqlServer, SqlCon)
                     .UseAutoSyncStructure(true) //自动同步实体结构到数据库
                     .Build(); //请务必定义成 Singleton 单例模式

                ListWorkTimeDto = new ObservableCollection<WorkTimeDto>();
                var WorkTimeQueryable = Fsql.Select<WorkTime>().ToList();
                foreach (var item in WorkTimeQueryable)
                {
                    ListWorkTimeDto.Add(new WorkTimeDto()
                    {
                        ID = item.Id,
                        Index = item.IndexNum,
                        ClassNum = item.ClassNum,
                        EndTime = item.EndTime,
                        StartTime = item.StartTime,
                        CreateTime = item.CreateTime
                    });
                }
                ListPlanCountDto = new ObservableCollection<PlanCountDto>();

                FormWorkTimeDto = new WorkTimeDto()
                {
                    IsFormValid = true,
                    //ClassNum="白班",
                    //StartTime="00:00",
                    //EndTime = "00:00"
                };

                FormPlanCountDto = new PlanCountDto()
                {
                    PlanDate = DateTime.Now

                };

                ClassNumComboBoxList = new List<ComboBoxModel>()
                {
                        new ComboBoxModel(){Key="0",Text="" },
                    new ComboBoxModel(){Key="1",Text="A" },
                    new ComboBoxModel(){Key="2",Text="B" },
                    new ComboBoxModel(){Key="3",Text="C" },
                    new ComboBoxModel(){Key="4",Text="D" }
                };

                SearchStartTime = DateTime.Now.AddDays(-5).ToShortDateString();
                SearchEndTime = DateTime.Now.AddDays(5).ToShortDateString();
                PlanCountSearch();

                CycleTime = 0;
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }

        /// <summary>
        /// 工作时间列表集合
        /// </summary>
        private ObservableCollection<WorkTimeDto> _ListWorkTimeDto;
        /// <summary>
        /// 工作时间列表集合
        /// </summary>
        public ObservableCollection<WorkTimeDto> ListWorkTimeDto
        {
            get { return _ListWorkTimeDto; }
            set { _ListWorkTimeDto = value; }
        }


        /// <summary>
        /// 计划产量列表集合
        /// </summary>
        private ObservableCollection<PlanCountDto> _ListPlanCountDto;
        /// <summary>
        /// 计划产量列表集合
        /// </summary>
        public ObservableCollection<PlanCountDto> ListPlanCountDto
        {
            get { return _ListPlanCountDto; }
            set { _ListPlanCountDto = value; }
        }

        #region "搜索条件"
        /// <summary>
        /// 搜索条件-班次
        /// </summary>
        private string _SearchClassNum;

        public string SearchClassNum
        {
            get
            {
                return _SearchClassNum;
            }
            set
            {
                _SearchClassNum = value;
                RaisePropertyChanged(() => SearchClassNum);
            }
        }

        /// <summary>
        /// 搜索条件-计划产量-开始时间
        /// </summary>
        private string _SearchStartTime;

        public string SearchStartTime
        {
            get
            {
                return _SearchStartTime;
            }
            set
            {
                _SearchStartTime = value;
                RaisePropertyChanged(() => SearchStartTime);
            }
        }

        /// <summary>
        /// 搜索条件-计划产量-结束时间
        /// </summary>
        private string _SearchEndTime;

        public string SearchEndTime
        {
            get
            {
                return _SearchEndTime;
            }
            set
            {
                _SearchEndTime = value;
                RaisePropertyChanged(() => SearchEndTime);
            }
        }



        #endregion

        #region "属性"
        /// <summary>
        /// 工作时间属性
        /// </summary>
        private WorkTimeDto _FormWorkTimeDto;

        public WorkTimeDto FormWorkTimeDto
        {
            get
            {
                return _FormWorkTimeDto;
            }
            set
            {
                _FormWorkTimeDto = value;
                RaisePropertyChanged(() => FormWorkTimeDto);
            }
        }

        /// <summary>
        /// 计划产量属性
        /// </summary>
        private PlanCountDto _FormPlanCountDto;

        public PlanCountDto FormPlanCountDto
        {
            get
            {
                return _FormPlanCountDto;
            }
            set
            {
                _FormPlanCountDto = value;
                RaisePropertyChanged(() => FormPlanCountDto);
            }
        }

        /// <summary>
        /// 节拍
        /// </summary>
        private int _CycleTime;

        public int CycleTime
        {
            get
            {
                return _CycleTime;
            }
            set
            {
                _CycleTime = value;
                RaisePropertyChanged(() => CycleTime);
            }
        }

        private List<ComboBoxModel> _ClassNumComboBoxList;
        /// <summary>
        /// 班次下拉框列表
        /// </summary>
        public List<ComboBoxModel> ClassNumComboBoxList
        {
            get { return _ClassNumComboBoxList; }
            set { _ClassNumComboBoxList = value; RaisePropertyChanged(() => ClassNumComboBoxList); }
        }


        /// <summary>
        /// 工作时间Grid选中属性
        /// </summary>
        private WorkTimeDto _DgSelectedWorkTimeDto;

        public WorkTimeDto DgSelectedWorkTimeDto
        {
            get
            {
                return _DgSelectedWorkTimeDto;
            }
            set
            {
                _DgSelectedWorkTimeDto = value;
                RaisePropertyChanged(() => DgSelectedWorkTimeDto);
            }
        }

        /// <summary>
        /// 计划产量Grid选中属性
        /// </summary>
        private PlanCountDto _DgSelectedPlanCountDto;

        public PlanCountDto DgSelectedPlanCountDto
        {
            get
            {
                return _DgSelectedPlanCountDto;
            }
            set
            {
                _DgSelectedPlanCountDto = value;
                RaisePropertyChanged(() => DgSelectedPlanCountDto);
            }
        }

        #endregion

        #region "命令"

        /// <summary>
        /// 工作时间-搜索命令
        /// </summary>
        private RelayCommand _SearchCmd;
        public RelayCommand SearchCmd
        {
            get
            {
                if (_SearchCmd == null) return new RelayCommand(() => WorkTimeSearch());
                return _SearchCmd;
            }
            set
            {
                _SearchCmd = value;
            }
        }

        private void WorkTimeSearch()
        {
            try
            {

                var MulConQueryable = Fsql.Select<WorkTime>();
                //多条件查询
                if (!string.IsNullOrEmpty(SearchClassNum))
                {
                    MulConQueryable = MulConQueryable.Where(t => t.ClassNum.Contains(SearchClassNum));
                }

                var ListDpI = MulConQueryable.OrderByDescending(a => a.CreateTime).ToList();//.Where(a => a.CreateTime >= DateTime.Now);
                ListWorkTimeDto.Clear();

                foreach (var item in ListDpI)
                {
                    ListWorkTimeDto.Add(new WorkTimeDto()
                    {
                        ID = item.Id,
                        ClassNum = item.ClassNum,
                        Index = item.IndexNum,
                        EndTime = item.EndTime,
                        StartTime = item.StartTime,
                        CreateTime = item.CreateTime
                    });
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }


        private void WorkTimeRefreshData()
        {
            try
            {
                var MulConQueryable = Fsql.Select<WorkTime>();

                var ListDpI = MulConQueryable.OrderByDescending(a => a.CreateTime).ToList();//.Where(a => a.CreateTime >= DateTime.Now);
                ListWorkTimeDto.Clear();

                foreach (var item in ListDpI)
                {
                    ListWorkTimeDto.Add(new WorkTimeDto()
                    {
                        ID = item.Id,
                        ClassNum = item.ClassNum,
                        Index = item.IndexNum,
                        EndTime = item.EndTime,
                        StartTime = item.StartTime,
                        CreateTime = item.CreateTime
                    });
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }



        /// <summary>
        /// 计划产量-搜索命令
        /// </summary>
        private RelayCommand _PlanCountSearchCmd;
        public RelayCommand PlanCountSearchCmd
        {
            get
            {
                if (_PlanCountSearchCmd == null) return new RelayCommand(() => PlanCountSearch());
                return _PlanCountSearchCmd;
            }
            set
            {
                _PlanCountSearchCmd = value;
            }
        }

        private void PlanCountSearch()
        {
            try
            {

                var MulConQueryable = Fsql.Select<PlanCount>();
                //多条件查询
                if (!string.IsNullOrEmpty(SearchStartTime))
                {
                    MulConQueryable = MulConQueryable.Where(t => t.CreateTime.Date >= Convert.ToDateTime(SearchStartTime));
                }
                //多条件查询
                if (!string.IsNullOrEmpty(SearchEndTime))
                {
                    MulConQueryable = MulConQueryable.Where(t => t.CreateTime.Date <= Convert.ToDateTime(SearchEndTime).AddDays(1));
                }

                var ListDpI = MulConQueryable.OrderByDescending(a => a.CreateTime).ToList();//.Where(a => a.CreateTime >= DateTime.Now);
                ListPlanCountDto.Clear();

                foreach (var item in ListDpI)
                {
                    ListPlanCountDto.Add(new PlanCountDto()
                    {
                        ID = item.Id,
                        ClassNum = item.ClassNum,
                        AGroup = item.AGroup,
                        BGroup = item.BGroup,
                        CGroup = item.CGroup,
                        PlanDate = item.PlanDate,
                        CreateTime = item.CreateTime
                    });
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }


        private void PlanCountRefreshData()
        {
            try
            {

                var MulConQueryable = Fsql.Select<PlanCount>();

                var ListDpI = MulConQueryable.OrderByDescending(a => a.CreateTime).ToList();//.Where(a => a.CreateTime >= DateTime.Now);
                ListPlanCountDto.Clear();

                foreach (var item in ListDpI)
                {
                    ListPlanCountDto.Add(new PlanCountDto()
                    {
                        ID = item.Id,
                        ClassNum = item.ClassNum,
                        AGroup = item.AGroup,
                        BGroup = item.BGroup,
                        CGroup = item.CGroup,
                        PlanDate = item.PlanDate,
                        CreateTime = item.CreateTime
                    });
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }
        #endregion

        #region "Grid选中命令"
        /// <summary>
        /// Grid1选中命令
        /// </summary>
        private RelayCommand<DataGrid> _SelectedItemsCmd;

        public RelayCommand<DataGrid> SelectedItemsCmd
        {
            get
            {
                if (_SelectedItemsCmd == null)
                    _SelectedItemsCmd = new RelayCommand<DataGrid>((p) => SelectedItemData(p));
                return _SelectedItemsCmd;
            }
            set { _SelectedItemsCmd = value; }
        }

        /// <summary>
        /// 选中数据
        /// </summary>
        private void SelectedItemData(DataGrid dv)
        {
            if (dv.SelectedItems.Count > 0)
            {
                DgSelectedWorkTimeDto = (WorkTimeDto)dv.SelectedItems[0];
            }
        }




        /// <summary>
        /// Grid2选中命令
        /// </summary>
        private RelayCommand<DataGrid> _SelectedItemCmd;

        public RelayCommand<DataGrid> SelectedItemCmd
        {
            get
            {
                if (_SelectedItemCmd == null)
                    _SelectedItemCmd = new RelayCommand<DataGrid>((p) => SelectedIteData(p));
                return _SelectedItemCmd;
            }
            set { _SelectedItemCmd = value; }
        }

        /// <summary>
        /// 选中数据
        /// </summary>
        private void SelectedIteData(DataGrid dv)
        {
            if (dv.SelectedItems.Count > 0)
            {
                DgSelectedPlanCountDto = (PlanCountDto)dv.SelectedItems[0];
            }
        }
        #endregion


        #region "新增命令"

        /// <summary>
        /// 增加命令
        /// </summary>
        private RelayCommand _CreateFormCmd;
        public RelayCommand CreateFormCmd
        {
            get
            {
                if (_CreateFormCmd == null) return new RelayCommand(() => CreateForm());
                return _CreateFormCmd;
            }

            set
            {
                _CreateFormCmd = value;
            }
        }

        private void CreateForm()
        {
            Messenger.Default.Send<String>("打开新增窗体数据", "Open_KanBan_WorkTimeCreate_CreateWindow");
        }


        /// <summary>
        /// 增加命令
        /// </summary>
        private RelayCommand _CreateCmd;
        public RelayCommand CreateCmd
        {
            get
            {
                if (_CreateCmd == null) return new RelayCommand(() => CreateData());
                return _CreateCmd;
            }

            set
            {
                _CreateCmd = value;
            }
        }

        /// <summary>
        /// 增加表单数据
        /// </summary>
        private void CreateData()
        {
            try
            {
                if (FormWorkTimeDto.IsValidated)
                {
                    Fsql.Insert<WorkTime>(new WorkTime()
                    {
                        IndexNum = FormWorkTimeDto.Index,
                        StartTime = FormWorkTimeDto.StartTime,
                        EndTime = FormWorkTimeDto.EndTime,
                        ClassNum = FormWorkTimeDto.ClassNum,
                    }).ExecuteAffrows();

                    //更新
                    WorkTimeRefreshData();
                    //FormWorkTimeDto.CreateTime = WorkTimeInfo.CreateTime;
                    //FormWorkTimeDto.ID = WorkTimeInfo.ID;
                    //ListWorkTimeDto.Insert(0, FormWorkTimeDto);

                    //DailyParameterInfoDto = new DailyParameterInfoDto();
                    Messenger.Default.Send<String>("关闭窗体", "CloseCurrentWindow");
                    //MessageBox.Show("添加成功"); 
                }
                else
                {
                    //FormWorkTimeDto.IsFormValid = true;
                    //var dataErrors = _dailyParameterInfoDto.dataErrors;
                    MessageBox.Show("请检查数据是否正确输入或者有未填写数据");
                };
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }
        #endregion

        #region "新增命令-计划产量"

        /// <summary>
        /// 增加命令
        /// </summary>
        private RelayCommand _PlanCountCreateFormCmd;
        public RelayCommand PlanCountCreateFormCmd
        {
            get
            {
                if (_PlanCountCreateFormCmd == null) return new RelayCommand(() => PlanCountCreateForm());
                return _PlanCountCreateFormCmd;
            }
            set
            {
                _PlanCountCreateFormCmd = value;
            }
        }

        private void PlanCountCreateForm()
        {
            FormPlanCountDto.PlanDate = DateTime.Now;
            Messenger.Default.Send<String>("打开新增窗体数据", "Open_KanBan_PlanCountCreate_CreateWindow");
        }

        /// <summary>
        /// 增加命令
        /// </summary>
        private RelayCommand _PlanCountCreateCmd;
        public RelayCommand PlanCountCreateCmd
        {
            get
            {
                if (_PlanCountCreateCmd == null) return new RelayCommand(() => PlanCountCreateData());
                return _PlanCountCreateCmd;
            }
            set
            {
                _PlanCountCreateCmd = value;
            }
        }

        /// <summary>
        /// 增加表单数据
        /// </summary>
        private void PlanCountCreateData()
        {
            try
            {
                if (FormPlanCountDto.IsValidated)
                {
                    Fsql.Insert<PlanCount>(new PlanCount()
                    {
                        AGroup = FormPlanCountDto.AGroup,
                        BGroup = FormPlanCountDto.BGroup,
                        CGroup = FormPlanCountDto.CGroup,
                        ClassNum = FormPlanCountDto.ClassNum,
                        PlanDate = FormPlanCountDto.PlanDate,
                    }).ExecuteAffrows();

                    //更新
                    PlanCountRefreshData();
                    //FormWorkTimeDto.CreateTime = WorkTimeInfo.CreateTime;
                    //FormWorkTimeDto.ID = WorkTimeInfo.ID;
                    //ListWorkTimeDto.Insert(0, FormWorkTimeDto);

                    //DailyParameterInfoDto = new DailyParameterInfoDto();
                    Messenger.Default.Send<String>("关闭窗体", "CloseCurrentWindow");
                    //MessageBox.Show("添加成功"); 
                }
                else
                {
                    //FormWorkTimeDto.IsFormValid = true;
                    //var dataErrors = _dailyParameterInfoDto.dataErrors;
                    MessageBox.Show("请检查数据是否正确输入或者有未填写数据");
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }
        #endregion

        #region "更新命令-计划产量"
        /// <summary>
        /// 修改数据命令
        /// </summary>
        private RelayCommand _PlanCountUpdateCmd;
        public RelayCommand PlanCountUpdateCmd
        {
            get
            {
                if (_PlanCountUpdateCmd == null) return new RelayCommand(() => PlanCountUpdateValue());
                return _PlanCountUpdateCmd;
            }
            set
            {
                _PlanCountUpdateCmd = value;
            }
        }

        /// <summary>
        /// 执行命令方法数据
        /// </summary>
        private void PlanCountUpdateValue()
        {
            try
            {

                if (DgSelectedPlanCountDto.IsValidated)
                {
                    //_DailyParameterInfoDataContext.Entities
                    var dpi = Fsql.Update<PlanCount>()
                        .Set(a => a.ClassNum, DgSelectedPlanCountDto.ClassNum)
                        .Set(a => a.AGroup, DgSelectedPlanCountDto.AGroup)
                        .Set(a => a.BGroup, DgSelectedPlanCountDto.BGroup)
                        .Set(a => a.CGroup, DgSelectedPlanCountDto.CGroup)
                        .Set(a => a.PlanDate, DgSelectedPlanCountDto.PlanDate)
                        .Where(a => a.Id == DgSelectedPlanCountDto.ID)
                        .ExecuteAffrows();

                    //更新
                    PlanCountRefreshData();

                    //DailyParameterInfoDto = new DailyParameterInfoDto();
                    Messenger.Default.Send<String>("关闭窗体", "CloseCurrentWindow");
                    //MessageBox.Show("添加成功"); 
                }
                else
                {
                    //DgSelectedDailyParameterInfoDto.IsFormValid = true;
                    //var dataErrors = DgSelectedDailyParameterInfoDto.dataErrors;
                    MessageBox.Show("请检查数据是否正确输入或者有未填写数据");
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }


        /// <summary>
        /// 修改弹窗命令
        /// </summary>
        private RelayCommand _PlanCountUpdateFormCmd;

        public RelayCommand PlanCountUpdateFormCmd
        {
            get
            {
                if (_PlanCountUpdateFormCmd == null) return new RelayCommand(() => PlanCountUpdateForm());
                return _PlanCountUpdateFormCmd;
            }
            set { _PlanCountUpdateFormCmd = value; }
        }

        /// <summary>
        /// 更新方法
        /// </summary>
        private void PlanCountUpdateForm()
        {
            if (DgSelectedPlanCountDto != null)
            {
                Messenger.Default.Send<String>("打开窗体", "Open_KanBan_PlanCountUpdate_UpdateWindow");
            }
            else
            {
                MessageBox.Show("请选中后再更新数据！", "提示", MessageBoxButton.OK);
            }

        }
        #endregion

        #region "更新命令"
        /// <summary>
        /// 修改数据命令
        /// </summary>
        private RelayCommand _UpdateCmd;
        public RelayCommand UpdateCmd
        {
            get
            {
                if (_UpdateCmd == null) return new RelayCommand(() => UpdateValue());
                return _UpdateCmd;
            }
            set
            {
                _UpdateCmd = value;
            }
        }

        /// <summary>
        /// 执行命令方法数据
        /// </summary>
        private void UpdateValue()
        {
            try
            {
                if (DgSelectedWorkTimeDto.IsValidated)
                {
                    //_DailyParameterInfoDataContext.Entities
                    Fsql.Update<WorkTime>()
                        .Set(a => a.IndexNum, DgSelectedWorkTimeDto.Index)
                        .Set(a => a.ClassNum, DgSelectedWorkTimeDto.ClassNum)
                        .Set(a => a.StartTime, DgSelectedWorkTimeDto.StartTime)
                        .Set(a => a.EndTime, DgSelectedWorkTimeDto.EndTime)
                        .Where(a => a.Id == DgSelectedWorkTimeDto.ID)
                        .ExecuteAffrows();

                    //更新
                    WorkTimeRefreshData();

                    //DailyParameterInfoDto = new DailyParameterInfoDto();
                    Messenger.Default.Send<String>("关闭窗体", "CloseCurrentWindow");
                    //MessageBox.Show("添加成功"); 
                }
                else
                {
                    //DgSelectedDailyParameterInfoDto.IsFormValid = true;
                    //var dataErrors = DgSelectedDailyParameterInfoDto.dataErrors;
                    MessageBox.Show("请检查数据是否正确输入或者有未填写数据");
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }
        }


        /// <summary>
        /// 修改弹窗命令
        /// </summary>
        private RelayCommand _UpdateFormCmd;

        public RelayCommand UpdateFormCmd
        {
            get
            {
                if (_UpdateFormCmd == null) return new RelayCommand(() => UpdateForm());
                return _UpdateFormCmd;
            }
            set { _UpdateFormCmd = value; }
        }

        /// <summary>
        /// 更新方法
        /// </summary>
        private void UpdateForm()
        {
            //DgSelectedWorkTimeDto.ID != null || DgSelectedWorkTimeDto.ID != Guid.Empty
            if (DgSelectedWorkTimeDto != null)
            {
                Messenger.Default.Send<String>("打开窗体", "Open_KanBan_WorkTimeUpdate_UpdateWindow");
            }
            else
            {
                MessageBox.Show("请选中后再更新数据！", "提示", MessageBoxButton.OK);
            }

        }
        #endregion

        #region "删除命令-计划产量"
        /// <summary>
        /// 删除命令
        /// </summary>
        private RelayCommand _PlanCountDeleteFormCmd;
        public RelayCommand PlanCountDeleteFormCmd
        {
            get
            {
                if (_PlanCountDeleteFormCmd == null) return new RelayCommand(() => PlanCountDeleteForm());
                return _PlanCountDeleteFormCmd;
            }
            set
            {
                _PlanCountDeleteFormCmd = value;
            }
        }

        private void PlanCountDeleteForm()
        {

            if (DgSelectedPlanCountDto.ID != null || DgSelectedPlanCountDto.ID != Guid.Empty)
            {
                MessageBoxResult result = MessageBox.Show("是否要删除当前数据！", "提示", MessageBoxButton.YesNo);
                if (result == MessageBoxResult.Yes)
                {
                    var DeleteInfo = Fsql.Delete<PlanCount>().Where(a => a.Id == DgSelectedPlanCountDto.ID).ExecuteDeleted().FirstOrDefault();
                    for (int i = 0; i < ListPlanCountDto.Count; i++)
                    {
                        if (DeleteInfo.Id == ListPlanCountDto[i].ID)
                        {
                            ListPlanCountDto.RemoveAt(i);
                        }
                    }
                }
                else
                {
                    // do something
                }
            }
            else
            {
                MessageBox.Show("请选中后再删除！", "提示", MessageBoxButton.OK);
            }

        }
        #endregion

        #region "删除命令"
        /// <summary>
        /// 删除命令
        /// </summary>
        private RelayCommand _DeleteFormCmd;
        public RelayCommand DeleteFormCmd
        {
            get
            {
                if (_DeleteFormCmd == null) return new RelayCommand(() => DeleteForm());
                return _DeleteFormCmd;
            }
            set
            {
                _DeleteFormCmd = value;
            }
        }

        private void DeleteForm()
        {
            try
            {
                if (DgSelectedWorkTimeDto != null || DgSelectedWorkTimeDto.ID != Guid.Empty)
                {
                    MessageBoxResult result = MessageBox.Show("是否要删除当前数据！", "提示", MessageBoxButton.YesNo);
                    if (result == MessageBoxResult.Yes)
                    {
                        var DeleteInfo = Fsql.Delete<WorkTime>().Where(a => a.Id == DgSelectedWorkTimeDto.ID).ExecuteDeleted().FirstOrDefault();
                        for (int i = 0; i < ListWorkTimeDto.Count; i++)
                        {
                            if (DeleteInfo.Id == ListPlanCountDto[i].ID)
                            {
                                ListWorkTimeDto.RemoveAt(i);
                            }
                        }

                    }
                    else
                    {
                        // do something
                    }
                }
                else
                {
                    MessageBox.Show("请选中后再删除！", "提示", MessageBoxButton.OK);
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(String.Format("ErrSource : {0} ErrMsg : {1}", ex.StackTrace.ToString(), ex.Message.ToString()));
            }

        }
        #endregion
        #region 全局命令



        private RelayCommand cancelCmd;

        public RelayCommand CancelCmd
        {
            get
            {
                if (cancelCmd == null) return new RelayCommand(() => CancelForm());
                return cancelCmd;
            }
            set { cancelCmd = value; }
        }
        /// <summary>
        /// 取消当前的窗口
        /// </summary>
        private void CancelForm()
        {
            FormWorkTimeDto = new WorkTimeDto();
            DgSelectedWorkTimeDto = new WorkTimeDto();

            FormPlanCountDto = new PlanCountDto();
            DgSelectedPlanCountDto = new PlanCountDto();

            Messenger.Default.Send<String>("关闭窗体", "CloseCurrentWindow");

        }


        private RelayCommand _CycleTimeTrue;

        public RelayCommand CycleTimeTrue
        {
            get
            {
                if (_CycleTimeTrue == null) return new RelayCommand(() => CycleTimeTrueAction());
                return _CycleTimeTrue;
            }
            set { _CycleTimeTrue = value; }
        }


        /// <summary>
        /// 节拍时间保存
        /// </summary>
        private void CycleTimeTrueAction()
        {
            ConfigHelper.SetValue("CycleTime", CycleTime.ToString());

        }

        #endregion

    }

}