ECS / WCS_LiuzhouZhituo · Files

using HHECS.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace HHECS.Controls
{
    /// <summary>
    /// 标准单叉堆垛机详情监控
    /// </summary>
    public partial class StockerInfo : UserControl
    {

        public event Func<Equipment, BllResult> DeleteTask; //删除任务
        public event Func<Location, Equipment, BllResult> DoubleInEvent;
        public event Func<Equipment, BllResult> EmptyOutEvent;
        public event Func<Equipment, BllResult> ForkErrorEvent;
        public event Func<Equipment, BllResult> OverrideTask; //重新下发任务
        public Equipment Self { get; set; }
        public string ControlName
        {
            get { return (string)GetValue(ControlNameProperty); }
            set { SetValue(ControlNameProperty, value); }
        }

        // Using a DependencyProperty as the backing store for ControlName.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ControlNameProperty =
            DependencyProperty.Register("ControlName", typeof(string), typeof(StockerInfo), new PropertyMetadata(""));


        public StockerInfo(int maxW, int maxH)
        {
            InitializeComponent();
            this.Width = maxW;
            this.Height = maxH;
            lab_Name.SetBinding(Label.ContentProperty, new Binding("ControlName") { Source = this });
        }

        public StockerInfo(int maxW)
        {
            InitializeComponent();
            this.Width = maxW;
            //this.Height = maxH;
            lab_Name.SetBinding(Label.ContentProperty, new Binding("ControlName") { Source = this });
        }

        /// <summary>
        /// 赋值属性
        /// </summary>
        /// <param name="deviceEntity"></param>
        /// <param name="props"></param>
        /// <param name="address"></param>
        public void SetProps(Equipment stocker)
        {
            Self = stocker;

            #region 固定属性赋值
            var Fork1ForkHasPallet = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet");
            if (Fork1ForkHasPallet != null)
            {
                lab_Fork1ForkHasPallet.Foreground = Brushes.Blue;
                switch (Fork1ForkHasPallet.Value)
                {
                    case "True":
                        lab_Fork1ForkHasPallet.Content = "有货";
                        break;
                    case "False":
                        lab_Fork1ForkHasPallet.Content = "无货";
                        break;
                    default:
                        lab_Fork1ForkHasPallet.Content = "未获取或不识别";
                        lab_Fork1ForkHasPallet.Foreground = Brushes.Red;
                        break;
                }
            }

            var Fork1TaskExcuteStatus = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus");
            if (Fork1TaskExcuteStatus != null)
            {
                lab_Fork1TaskExcuteStatus.Foreground = Brushes.Blue;
                TaskExcuteStatus temp = (TaskExcuteStatus)(Convert.ToInt32(Fork1TaskExcuteStatus.Value));
                switch (temp)
                {
                    case TaskExcuteStatus.待机:
                    case TaskExcuteStatus.任务执行中:
                    case TaskExcuteStatus.任务完成:
                        lab_Fork1TaskExcuteStatus.Content = temp.ToString();
                        break;
                    case TaskExcuteStatus.任务中断_出错:
                    case TaskExcuteStatus.下发任务错误:
                        lab_Fork1TaskExcuteStatus.Content = temp.ToString();
                        lab_Fork1TaskExcuteStatus.Foreground = Brushes.Red;
                        break;
                    default:
                        lab_Fork1TaskExcuteStatus.Content = "未获取或不识别";
                        lab_Fork1TaskExcuteStatus.Foreground = Brushes.Red;
                        break;
                }
            }

            var operationModel = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel");
            if (operationModel != null)
            {
                lab_OperationModel.Foreground = Brushes.Blue;
                OperationModel temp = (OperationModel)(Convert.ToInt32(operationModel.Value));
                switch (temp)
                {
                    case OperationModel.维修:
                    case OperationModel.手动:
                    case OperationModel.机载操作:
                    case OperationModel.单机自动:
                    case OperationModel.联机:
                        lab_OperationModel.Content = temp.ToString();
                        break;
                    default:
                        lab_OperationModel.Content = "未获取或不识别";
                        lab_OperationModel.Foreground = Brushes.Red;
                        break;
                }
            }

            var taskLimit = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "TaskLimit");
            if (taskLimit != null)
            {
                lab_TaskLimit.Foreground = Brushes.Blue;
                TaskLimit temp = (TaskLimit)Convert.ToInt32(taskLimit.Value);
                switch (temp)
                {
                    case TaskLimit.无限制:
                    case TaskLimit.限制入库:
                    case TaskLimit.限制出库:
                    case TaskLimit.拣选:
                        lab_TaskLimit.Content = temp.ToString();
                        break;
                    default:
                        lab_TaskLimit.Content = "未获取或不识别";
                        lab_TaskLimit.Foreground = Brushes.Red;
                        break;
                }
            }

            var Fork1TaskType = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskType");
            if (Fork1TaskType != null)
            {
                lab_Fork1TaskType.Foreground = Brushes.Blue;
                ForkTaskFlag temp = (ForkTaskFlag)Convert.ToInt32(Fork1TaskType.Value);
                switch (temp)
                {
                    case ForkTaskFlag.无任务:
                    case ForkTaskFlag.库内取货:
                    case ForkTaskFlag.库内放货:
                    case ForkTaskFlag.库外入库:
                    case ForkTaskFlag.库外出库:
                    case ForkTaskFlag.重新分配入库地址:
                    case ForkTaskFlag.删除任务:
                    case ForkTaskFlag.任务完成:
                        lab_Fork1TaskType.Content = temp.ToString();
                        break;
                    default:
                        lab_Fork1TaskType.Content = "未获取或不识别";
                        lab_Fork1TaskType.Foreground = Brushes.Red;
                        break;
                }
            }

            var Fork1TaskNo = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskNo");
            if (Fork1TaskNo != null)
            {
                lab_Fork1TaskNo.Content = Fork1TaskNo.Value;
            }

            var CurrentStation = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentStation");
            if (CurrentStation != null)
            {
                lab_CurrentStation.Content = CurrentStation.Value;
            }

            var currentColumn = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentColumn");
            if (currentColumn != null)
            {
                lab_CurrentColumn.Content = currentColumn.Value;
            }

            var currentLayer = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentLayer");
            if (currentLayer != null)
            {
                lab_CurrentLayer.Content = currentLayer.Value;
            }

            var horizontalDistance = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "HorizontalDistance");
            if (horizontalDistance != null)
            {
                lab_HorizontalDistance.Content = horizontalDistance.Value;
            }

            var verticalDistance = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "VerticalDistance");
            if (verticalDistance != null)
            {
                lab_VerticalDistance.Content = verticalDistance.Value;
            }

            var ForkDistance = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "ForkDistance");
            if (ForkDistance != null)
            {
                lab_ForkDistance.Content = ForkDistance.Value;
            }


            #endregion

            //监控属性赋值
            var tempProps = stocker.EquipmentProps.FindAll(t => t.EquipmentTypePropTemplate.IsMonitor == true);
            foreach (var item in tempProps)
            {
                if (item.Value != item.EquipmentTypePropTemplate.MonitorCompareValue)
                {
                    AddAlarm("报警：" + item.EquipmentTypePropTemplate.Name + " 信息：" + item.EquipmentTypePropTemplate.MonitorFailure, 2);
                }
                else
                {
                    RemoveAlarm("报警：" + item.EquipmentTypePropTemplate.Name + " 信息：" + item.EquipmentTypePropTemplate.MonitorFailure);
                }
            }
        }

        private void RemoveAlarm(string v)
        {
            for (int i = list_Alarm.Items.Count - 1; i >= 0; i--)
            {
                var a = (TextBlock)list_Alarm.Items[i];
                if (a.Text.Contains(v))
                {
                    list_Alarm.Items.Remove(list_Alarm.Items[i]);
                }
            }
        }

        /// <summary>
        /// 添加报警
        /// </summary>
        /// <param name="log"></param>
        /// <param name="level">1显示绿色，2显示红色</param>
        public void AddAlarm(string log, int level)
        {
            //先找存不存在
            foreach (var item in list_Alarm.Items)
            {
                var a = (TextBlock)item;
                if (a.Text.Contains(log))
                {
                    //存在就不再次添加
                    return;
                }
            }
            TextBlock textBlock = new TextBlock
            {
                Text = DateTime.Now.ToLongTimeString() + ":" + log
            };
            switch (level)
            {
                case 1:
                    textBlock.Background = Brushes.Green;
                    break;
                case 2:
                    textBlock.Background = Brushes.Red;
                    break;
            }
            textBlock.MaxWidth = this.Width;
            textBlock.TextWrapping = TextWrapping.Wrap;
            this.list_Alarm.Items.Add(textBlock);
            this.list_Alarm.SelectedIndex = this.list_Alarm.Items.Count - 1;
            this.list_Alarm.ScrollIntoView(this.list_Alarm.SelectedItem);
        }

        /// <summary>
        /// 处理重入
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_DIn_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("是否要进行重入处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {
                if (Self != null)
                {
                    var doubleIn = Self.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1DoubleIn");
                    if (doubleIn != null)
                    {
                        if (doubleIn.Value == "True")
                        {
                            WinLocationInput frm_LocationInput = new WinLocationInput
                            {
                                DeviceEntity = Self
                            };
                            if (frm_LocationInput.ShowDialog() == true)
                            {
                                Location locationEntity = frm_LocationInput.NewLocation;
                                BllResult a = DoubleInEvent?.Invoke(locationEntity, Self);
                                if (a == null)
                                {
                                    MessageBox.Show("未处理重入事件");
                                }
                                else
                                {
                                    if (a.Success)
                                    {
                                        MessageBox.Show("重入处理成功");
                                    }
                                    else
                                    {
                                        MessageBox.Show("重入处理失败:" + a.Msg);
                                    }
                                }
                            }
                        }
                        else
                        {
                            MessageBox.Show("当前没有重入报警，无需处理");
                        }
                    }
                    else
                    {
                        MessageBox.Show("未找到堆垛机的重入属性");
                    }
                }
                else
                {
                    MessageBox.Show("无重入需要处理");
                }
            }
        }

        /// <summary>
        /// 空出处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_EOut_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("是否要进行空出处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {
                if (Self != null)
                {
                    var emptyOut = Self.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1EmptyOut");
                    if (emptyOut != null)
                    {
                        if (emptyOut.Value == "True")
                        {
                            BllResult temp = EmptyOutEvent?.Invoke(Self);
                            if (temp == null)
                            {
                                MessageBox.Show("未处理空出事件");
                            }
                            else
                            {
                                if (temp.Success)
                                {
                                    MessageBox.Show("空出处理成功");
                                }
                                else
                                {
                                    MessageBox.Show("空出处理失败：" + temp.Msg);
                                }
                            }
                        }
                        else
                        {
                            MessageBox.Show("当前没有空出报警，无需处理");
                        }
                    }
                    else
                    {
                        MessageBox.Show("未找到堆垛机的空出属性");
                    }
                }
                else
                {
                    MessageBox.Show("无需空出处理");
                }
            }
        }

        /// <summary>
        /// 重新写入任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Override_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("是否要进行任务重新下发处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {
                if (Self != null)
                {
                    var temp = OverrideTask?.Invoke(Self);
                    if (temp == null)
                    {
                        MessageBox.Show("未处理重写事件");
                    }
                    else if (temp.Success)
                    {
                        MessageBox.Show("重新下发成功");
                    }
                    else
                    {
                        MessageBox.Show($"重新下发失败:{temp.Msg}");
                    }
                }
                else
                {
                    MessageBox.Show("堆垛机未赋值");
                }
            }
        }

        /// <summary>
        /// 取货错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_ForkError_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("是否要进行取货错误处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {
                if (Self != null)
                {
                    var forkError = Self.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1PickupTaskError");
                    if (forkError != null)
                    {
                        if (forkError.Value == "True")
                        {
                            var temp = ForkErrorEvent?.Invoke(Self);
                            if (temp == null)
                            {
                                MessageBox.Show("未处理取货错误事件");
                            }
                            if (temp.Success)
                            {
                                MessageBox.Show("取货错误处理成功");
                            }
                            else
                            {
                                MessageBox.Show($"取货错误处理失败：{temp.Msg}");
                            }
                        }
                        else
                        {
                            MessageBox.Show("当前没有取货错误报警，无需处理");
                        }
                    }
                    else
                    {
                        MessageBox.Show("未找到堆垛机的取货错误属性");
                    }
                }
                else
                {
                    MessageBox.Show("堆垛机未赋值");
                }
            }
        }

        /// <summary>
        /// 删除任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Delete_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("是否要进行任务删除处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {

                var temp = DeleteTask?.Invoke(Self);
                if (temp == null)
                {
                    MessageBox.Show("未处理任务删除事件");
                }
                if (temp.Success)
                {
                    MessageBox.Show("任务删除处理成功");
                }
                else
                {
                    MessageBox.Show($"任务删除失败：{temp.Msg}");
                }

            }
        }
    }
}