Files
6098/Cowain.Bake.UI/Home/ViewModels/WorkOrderViewModel.cs

674 lines
25 KiB
C#
Raw Normal View History

using Cowain.Bake.BLL;
using Cowain.Bake.Common;
using Cowain.Bake.Common.Enums;
using Cowain.Bake.Model;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Unity;
using Prism.Commands;
using System.Windows;
using HandyControl.Controls;
using Cowain.Bake.Model.Entity;
using System.ComponentModel;
using Newtonsoft.Json;
using System.Data;
using Cowain.Bake.Common.Core;
using static Cowain.Bake.Common.Models.MESModel;
using JSON = Newtonsoft.Json.JsonConvert;
using Cowain.Bake.Common.Interface;
using System.Text.RegularExpressions;
using Cowain.Bake.Communication.MOM;
namespace Cowain.Bake.UI.Home.ViewModels
{
public class WorkOrderViewModel : ViewModelBase, INavigationAware
{
public WorkOrderViewModel(IUnityContainer unityContainer, IRegionManager regionManager) : base(unityContainer, regionManager)
{
this.PageTitle = "创建工单";
SetDummyRuleList();
isAllowed = unityContainer.Resolve<UserService>().CheckPermission(ERole.Mantainer);
}
private bool isAllowed;
public bool IsAllowed
{
get => isAllowed;
set => SetProperty(ref isAllowed, value);
}
//工单列表
private ObservableCollection<WorkOrderFormulaEntity> workOrderList;
public ObservableCollection<WorkOrderFormulaEntity> WorkOrderList
{
get => workOrderList ?? (workOrderList = new ObservableCollection<WorkOrderFormulaEntity>());
set { SetProperty(ref workOrderList, value); }
}
//配方列表
private ObservableCollection<TProcessParameter> formulaList = new ObservableCollection<TProcessParameter>();
public ObservableCollection<TProcessParameter> FormulaList
{
get => formulaList;
set { SetProperty(ref formulaList, value); }
}
//参数列表
private ObservableCollection<EqptParameterModel> paramList;
public ObservableCollection<EqptParameterModel> ParamList
{
get => paramList ?? (paramList = new ObservableCollection<EqptParameterModel>());
set
{
if (value != paramList)
{
paramList = value;
OnPropertyChanged("ParamList");
}
}
}
private WorkOrderFormulaEntity workOrderSelectedItem;
public WorkOrderFormulaEntity WorkOrderSelectedItem
{
get { return workOrderSelectedItem; }
set
{
if (value != null)
{
workOrderSelectedItem = value;
OnPropertyChanged("WorkOrderSelectedItem");
}
if (workOrderSelectedItem != null)
{
FormulaSelectedItem = FormulaList.FirstOrDefault(x => x.Id == workOrderSelectedItem.ProcessParamId);
}
else
{
FormulaSelectedItem = null;
}
}
}
private TProcessParameter formulaSelectedItem;
public TProcessParameter FormulaSelectedItem
{
get { return formulaSelectedItem; }
set
{
if (value != null)
{
formulaSelectedItem = value;
OnPropertyChanged("FormulaSelectedItem");
}
}
}
private TProcessParameter formulaComboSelectedItem;
public TProcessParameter FormulaComboSelectedItem
{
get { return formulaComboSelectedItem; }
set
{
if (value != null)
{
formulaComboSelectedItem = value;
OnPropertyChanged("FormulaComboSelectedItem");
}
}
}
private TProcessParameter reFormulaComboSelectedItem;
public TProcessParameter ReFormulaComboSelectedItem
{
get { return reFormulaComboSelectedItem; }
set
{
if (value != null)
{
reFormulaComboSelectedItem = value;
OnPropertyChanged("ReFormulaComboSelectedItem");
}
}
}
private string dummyComboSelectedItem;
public string DummyComboSelectedItem
{
get { return dummyComboSelectedItem; }
set
{
if (value != null)
{
dummyComboSelectedItem = value;
OnPropertyChanged("DummyComboSelectedItem");
}
}
}
//实现INotifyPropertyChanged接口
public event PropertyChangedEventHandler NotifyPropertyChanged;
public void OnPropertyChanged(string propName)
{
if (NotifyPropertyChanged != null)
{
NotifyPropertyChanged.Invoke(this, new PropertyChangedEventArgs(propName));
}
}
//工单textbox双绑定
private string workOrder = string.Empty;
public string WorkOrder
{
get { return workOrder; }
set
{
if (value != null)
{
workOrder = value;
OnPropertyChanged("WorkOrder");
}
}
}
//配方textbox双绑定
private string formula;
public string Formula
{
get => formula;
set => SetProperty(ref formula, value);
}
private Visibility buttonVisibility = Visibility.Hidden;
public Visibility ButtonVisibility
{
get { return buttonVisibility; }
set
{
buttonVisibility = value;
OnPropertyChanged("ButtonVisibility");
}
}
public List<WorkOrderFormulaEntity> CurrentOrderList { get; set; }
//设置水含量电芯下拉框数据源
public List<string> DummyRuleList { get; set; }
private void SetDummyRuleList()
{
DummyRuleList = new List<string>();
foreach (DummyPlaceRule dummyPlaceRule in Enum.GetValues(typeof(DummyPlaceRule)))
{
DummyRuleList.Add(dummyPlaceRule.GetDescription());
}
}
public void AsyncRefreshTask()
{
Application.Current?.Dispatcher?.Invoke(new Action(() =>
{
Refresh();
}));
}
public override void Refresh()
{
WorkOrderList.Clear();
FormulaList.Clear();
var listWorkOrderFormula = _unityContainer.Resolve<ProductionInformationService>().GetAllCellWorkOrderFormula();
var listFormula = _unityContainer.Resolve<ProcessParamService>().GetAllFormula();
listWorkOrderFormula.ForEach(x => WorkOrderList.Add(x));
listFormula.ForEach(x => FormulaList.Add(x));
CurrentOrderList = listWorkOrderFormula;
if (!string.IsNullOrEmpty(Formula))
{
if (-1 != paraID)
{
GetSelectJSON();
}
}
}
private void GetSelectJSON()
{
foreach (var item in WorkOrderList)
{
if (true == item.CurrentProduct)
{
var memory = _unityContainer.Resolve<MemoryDataProvider>();
memory.CurrentUser.JobNum = item.JobNum;
memory.CurrentUser.ProcessParamName = item.ProcessParamName;
_unityContainer.Resolve<ICommonFun>().ModifyOrderNum();
}
}
var paramData = _unityContainer.Resolve<ProcessParamService>().GetProcessParam(paraID);
ParamList.Clear();
var operationList = JsonConvert.DeserializeObject<List<EqptParameterModel>>(paramData);
operationList.ForEach(a => ParamList.Add(a));
Formula = FormulaSelectedItem.ProcessParamName;
paraID = FormulaSelectedItem.Id;
}
private int paraID = -1;
//配方datagrid的SelectionChanged命令
public DelegateCommand<object> SelectionChangedCommand => new DelegateCommand<object>((x) =>
{
if (FormulaSelectedItem != null)
{
ParamList.Clear();
var operationList = JsonConvert.DeserializeObject<List<EqptParameterModel>>(FormulaSelectedItem.Parameters);
operationList.ForEach(a => ParamList.Add(a));
Formula = FormulaSelectedItem.ProcessParamName;
paraID = FormulaSelectedItem.Id;
}
else
{
ParamList = null;
}
});
public DelegateCommand<string> DeleteCommand => new DelegateCommand<string>((x) =>
{
int delCount = 0;
if (x == "deleteWorkOrder")
{
var result = HandyControl.Controls.MessageBox.Ask($@"确定删除?", "操作提示");
if (result == System.Windows.MessageBoxResult.Cancel)
{
return;
}
if (workOrderSelectedItem != null)
{
var deleteItem = workOrderSelectedItem as TProductionInformation;
if (_unityContainer.Resolve<ProductionInformationService>().GetIsInUse(deleteItem.Id))
{
HandyControl.Controls.MessageBox.Fatal($@"工单正在使用,请修改当前使用工单后重试", "操作提示");
return;
}
delCount = _unityContainer.Resolve<ProductionInformationService>().Delete<TProductionInformation>(deleteItem.Id);
WorkOrderList.Remove(WorkOrderSelectedItem);
CurrentOrderList.Remove(WorkOrderSelectedItem);
_unityContainer.Resolve<LogService>().AddLog("WorkOrderViewModel.DeleteCommand:deleteWorkOrder," +
JsonConvert.SerializeObject(WorkOrderSelectedItem), E_LogType.Operate.ToString());
}
else
{
return;
}
}
else if (x == "deleteFormula")
{
if (formulaSelectedItem != null)
{
if (null != CurrentOrderList.Find(item => item.ProcessParamId == FormulaSelectedItem.Id && item.CurrentProduct.Value == true))
{
HandyControl.Controls.MessageBox.Fatal($@"此配方有工单正在使用,请修改当前使用工单后重试", "操作提示");
return;
}
if (null != CurrentOrderList.Find(item => item.ProcessParamId == FormulaSelectedItem.Id || item.ReProcessParamId == FormulaSelectedItem.Id))
{
HandyControl.Controls.MessageBox.Fatal($@"此配方有工单在使用,请先删除工单!", "操作提示");
return;
}
var result1 = HandyControl.Controls.MessageBox.Ask($@"确定删除此配方?该操作会删除所有绑定此配方的工单", "操作提示");
if (result1 == System.Windows.MessageBoxResult.Cancel)
{
return;
}
delCount = _unityContainer.Resolve<ProcessParamService>().Delete(FormulaSelectedItem);
_unityContainer.Resolve<ProductionInformationService>().Delete(FormulaSelectedItem.Id);
FormulaList.Remove(FormulaSelectedItem);
_unityContainer.Resolve<LogService>().AddLog("WorkOrderViewModel.DeleteCommand:deleteFormula," +
JsonConvert.SerializeObject(FormulaSelectedItem), E_LogType.Operate.ToString());
paraID = -1;
Refresh();
}
else
{
return;
}
}
if (delCount > 0)
{
Growl.Success("删除成功!");
}
else
{
Growl.Fatal("删除失败!");
}
});
public DelegateCommand<string> QueryCommand => new DelegateCommand<string>((x) =>
{
List<WorkOrderFormulaEntity> queryWorkOrderList;
List<TProcessParameter> queryFormulaList;
if (x == "queryWorkOrder")
{
if (!string.IsNullOrWhiteSpace(WorkOrder))
{
WorkOrderList.Clear();
queryWorkOrderList = _unityContainer.Resolve<ProductionInformationService>().QueryWorkOrder(WorkOrder);
if (0 != queryWorkOrderList.Count)
{
queryWorkOrderList.ForEach(i => WorkOrderList.Add(i));
Growl.Success("查询完成!");
}
else
{
Growl.Success("没有数据!");
}
}
else
{
Refresh();
return;
}
}
else if (x == "queryFormula")
{
if (!string.IsNullOrWhiteSpace(Formula))
{
FormulaList.Clear();
queryFormulaList = _unityContainer.Resolve<ProcessParamService>().QueryFormula(Formula);
if (0 != queryFormulaList.Count)
{
queryFormulaList.ForEach(i => FormulaList.Add(i));
Growl.Success("查询完成!");
}
else
{
Growl.Success("没有数据!");
}
}
else
{
Refresh();
return;
}
}
});
private EqptParameterModel selectedItem;
public EqptParameterModel SelectedItem
{
get => selectedItem;
set => SetProperty(ref selectedItem, value);
}
public DelegateCommand<object> CellEditEndingCommand => new DelegateCommand<object>((x) =>
{
if (null == selectedItem)
{
return;
}
string regular = "";
if (BasicFramework.Instance.RegularDic.ContainsKey(selectedItem.ParameterType))
{
regular = BasicFramework.Instance.RegularDic[selectedItem.ParameterType];
}
else
{
regular = BasicFramework.Instance.RegularDic["Int32"];
}
Regex regex = new Regex(regular);
if (!regex.IsMatch(selectedItem.TargetValue))
{
Refresh();
Growl.Error("参数格式不正确!");
}
});
//工艺参数是否超出范围
bool IsParamOutRange()
{
float min , max, value;
foreach (var item in ParamList)
{
if (string.IsNullOrEmpty(item.LowerLimit)
|| string.IsNullOrEmpty(item.TargetValue)
|| string.IsNullOrEmpty(item.UpperLimit))
{
LogHelper.Instance.Error($"工艺参数相关项不能为空,内容为:{JSON.SerializeObject(item)}", true);
continue;
}
try
{
max = float.Parse(item.UpperLimit);
min = float.Parse(item.LowerLimit);
value = float.Parse(item.TargetValue);
if (max < value || min > value)
{
LogHelper.Instance.Error($"工艺参数值超出上限或下限值,内容为:{JSON.SerializeObject(item)}", true);
return false;
}
}
catch (Exception ex)
{
LogHelper.Instance.Error($"上限值、下限值、设置值异常,异常内容:{ex.Message},内容为:{JSON.SerializeObject(item)}", true);
return false;
}
}
return true;
}
public DelegateCommand RefreshFormulaCommand => new DelegateCommand(() =>
{
Refresh();
});
/*
MOMMOM检查参数是否允许修改
*/
public DelegateCommand<string> SaveFormulaCommand => new DelegateCommand<string>((x) =>
{
//参数变更, 先判断是否超出范围
if (!IsParamOutRange())
{
Refresh();
return;
}
int mesEnable = int.Parse(_unityContainer.Resolve<SysSetupService>().GetValueByParaID(ESysSetup.MOMEnable.ToString()));
//MOM验证结果 add by lsm 20250926 test
if (mesEnable == (int)EMOMEnable.Enable)
{
var memory = _unityContainer.Resolve<MemoryDataProvider>();
MESReturnCmdModel mesResult = _unityContainer.Resolve<MESProcess>().ChangeParam(memory.CurrentUser.UserId, new List<EqptParameterModel>(ParamList));
if (null == mesResult
|| mesResult.Info.ResultFlag != EResultFlag.OK.ToString())
{
if (null == mesResult)
{
LogHelper.Instance.Warn($"MOM验证参数变更失败,返回信息:{JSON.SerializeObject(mesResult)}", true);
}
else
{
LogHelper.Instance.Warn($"MOM验证参数变更失败,返回信息:{mesResult.Info.MOMMessage}", true);
}
Refresh();
return;
}
}
//参数保存
if (_unityContainer.Resolve<ProcessParamService>().UpdateProcessParam(paraID, JsonConvert.SerializeObject(ParamList)))
{
Refresh();
Growl.Success("更新成功!");
}
});
//AddProcessParaCommand
public DelegateCommand<string> AddProcessParaCommand => new DelegateCommand<string>((x) =>
{
if (string.IsNullOrEmpty(formula))
{
Growl.Error("配方名称不能为空!");
return;
}
if (!_unityContainer.Resolve<ProcessParamService>().CreateNewProcessParam(formula))
{
Growl.Error("配方名称重复!");
return;
}
Refresh();
Growl.Info("新增配方成功!");
});
public DelegateCommand<string> AddCommand => new DelegateCommand<string>((x) =>
{
if (x == "addWorkOrder")
{
if (string.IsNullOrWhiteSpace(WorkOrder))
{
Growl.Info("请输入工单号!");
return;
}
if (FormulaComboSelectedItem == null)
{
Growl.Info("请选择配方!");
return;
}
if (ReFormulaComboSelectedItem == null)
{
Growl.Info("请选择复烘配方!");
return;
}
if (string.IsNullOrWhiteSpace(DummyComboSelectedItem))
{
Growl.Info("请选择水含量电芯放盘规则!");
return;
}
if (CurrentOrderList.Count > 0)
{
if (CurrentOrderList.Where(b => b.JobNum == workOrder).ToList().Count > 0)
{
Growl.Info("工单已存在!");
return;
};
}
else
{
return;
}
//从当前工单列表中找到当前生产的工单
//var u = CurrentOrderList.Where(c => c.CurrentProduct == true).ToList()[0];
//TProductionInformation updateItem = new TProductionInformation()
//{
// Id = u.Id,
// JobNum = u.JobNum,
// CurrentProduct = false,
// DummyRule = u.DummyRule,
// ProcessParamId = u.ProcessParamId
//};
//workOrderService.Update(updateItem);
DummyPlaceRule d = EnumHelper.GetValueByDescription<DummyPlaceRule>(DummyComboSelectedItem);
int selectedDummyRule = (int)Enum.Parse(typeof(DummyPlaceRule), d.ToString());
int proccessParamId = FormulaComboSelectedItem.Id;
TProductionInformation newWorkOrder = new TProductionInformation()
{
JobNum = WorkOrder,
CurrentProduct = false,
DummyRule = Convert.ToSByte(selectedDummyRule),
ProcessParamId = proccessParamId,
ReProcessParamId = ReFormulaComboSelectedItem.Id,
};
_unityContainer.Resolve<ProductionInformationService>().Insert(newWorkOrder);
_unityContainer.Resolve<LogService>().AddLog("WorkOrderViewModel.AddCommand:"
+ JsonConvert.SerializeObject(newWorkOrder), E_LogType.Operate.ToString());
Refresh();
var UpdateProduceModel = workOrderList.Where(a => a.CurrentProduct == true && a.JobNum != WorkOrder).ToList();
Growl.Success("新增成功!");
}
else if (x == "addFormula")
{
TProcessParameter newFormula = new TProcessParameter();
}
});
public DelegateCommand<object> CurrentProduceCheckBoxChangeCommand => new DelegateCommand<object>((x) =>
{
var result = HandyControl.Controls.MessageBox.Ask($@"确定更改?", "操作提示");
if (result == System.Windows.MessageBoxResult.Cancel)
{
Refresh();
return;
}
var clickItem = WorkOrderSelectedItem;
//if (clickItem.IsRebake == true)
//{
// HandyControl.Controls.MessageBox.Error("无法将复烘配方选择为生产配方");
// Refresh();
// return;
//}
if (_unityContainer.Resolve<ProcessParamService>().UpdateCurrentJobNum(clickItem.Id))
{
Refresh();
}
else
{
Growl.Info("必须有一个正在的生产工单");
Refresh();
}
});
//public DelegateCommand<object> RebakeBoxChangeCommand => new DelegateCommand<object>((x) =>
//{
// var result = HandyControl.Controls.MessageBox.Ask($@"选择此工单为复烘配方?", "操作提示");
// if (result == System.Windows.MessageBoxResult.Cancel)
// {
// Refresh();
// return;
// }
// var clickItem = WorkOrderSelectedItem;
// if (clickItem.CurrentProduct == true)
// {
// HandyControl.Controls.MessageBox.Error("无法将正在生产的工单选择为复烘配方");
// Refresh();
// return;
// }
// if (_unityContainer.Resolve<ProcessParamService>().UpdateRebake(clickItem.Id))
// {
// Refresh();
// }
// else
// {
// Growl.Info("必须有一个复烘配方");
// Refresh();
// }
//});
void INavigationAware.OnNavigatedTo(NavigationContext navigationContext)
{
// 导航到当前页面时的处理逻辑,先执行构造方法,再执行本方法
}
bool INavigationAware.IsNavigationTarget(NavigationContext navigationContext)
{
return false; //false:表示每次导航都创建新实例,不重用旧实例; true:用旧实例,不会执行构造方法
}
void INavigationAware.OnNavigatedFrom(NavigationContext navigationContext)
{
//相当于析构方法,退出时(切换时)再执行。
// 在这里添加释放旧视图实例资源的代码
}
}
}