新增密炼物料皮重策略功能,包括相关实体、服务、控制器及接口,支持桌面端免密CRUD操作,优化打印记录与原料入场记录的衍生字段填充逻辑,提升用户体验。

This commit is contained in:
geht
2026-06-02 16:28:51 +08:00
parent 37239e1b0a
commit fef7d25e3c
75 changed files with 4407 additions and 170 deletions

View File

@@ -0,0 +1,295 @@
using HandyControl.Tools.Extension;
using System.Collections.ObjectModel;
using YY.Admin.Core;
using YY.Admin.Core.Entity;
using YY.Admin.Core.Services;
using YY.Admin.Core.Session;
using YY.Admin.ViewModels.RawMaterialEntry;
using YY.Admin.ViewModels.WeightRecord;
using YY.Admin.Views.RawMaterialEntry;
using YY.Admin.Views.WeightRecord;
namespace YY.Admin.ViewModels.MixerMaterialTareStrategy;
public class MixerMaterialTareStrategyEditDialogViewModel : BaseViewModel, IDialogResultable<bool>
{
private readonly IMixerMaterialTareStrategyService _tareStrategyService;
private MesXslMixerMaterialTareStrategy? _strategy;
public MesXslMixerMaterialTareStrategy? Strategy
{
get => _strategy;
set => SetProperty(ref _strategy, value);
}
public bool IsAddMode => string.IsNullOrWhiteSpace(Strategy?.Id) || (Strategy?.Id?.StartsWith("local-") ?? false);
public string DialogTitle => IsAddMode ? "新增密炼物料皮重策略" : "编辑密炼物料皮重策略";
public ObservableCollection<MesXslUnit> UnitOptions { get; } = new();
private MesMixerMaterial? _selectedMaterial;
public MesMixerMaterial? SelectedMaterial
{
get => _selectedMaterial;
set
{
SetProperty(ref _selectedMaterial, value);
RaisePropertyChanged(nameof(SelectedMaterialDisplay));
RaisePropertyChanged(nameof(HasSelectedMaterial));
if (Strategy != null && value != null)
{
Strategy.MixerMaterialId = value.Id;
Strategy.MixerMaterialName = value.MaterialName;
RaisePropertyChanged(nameof(Strategy));
}
}
}
public string SelectedMaterialDisplay => _selectedMaterial != null
? $"[{_selectedMaterial.MaterialCode}] {_selectedMaterial.MaterialName}"
: (string.IsNullOrWhiteSpace(Strategy?.MixerMaterialName) ? "请选择密炼物料" : Strategy!.MixerMaterialName!);
public bool HasSelectedMaterial =>
_selectedMaterial != null || !string.IsNullOrWhiteSpace(Strategy?.MixerMaterialId);
private MesXslSupplier? _selectedSupplier;
public MesXslSupplier? SelectedSupplier
{
get => _selectedSupplier;
set
{
SetProperty(ref _selectedSupplier, value);
RaisePropertyChanged(nameof(SelectedSupplierDisplay));
RaisePropertyChanged(nameof(HasSelectedSupplier));
if (Strategy != null && value != null)
{
Strategy.SupplierId = value.Id;
Strategy.SupplierName = value.SupplierName;
RaisePropertyChanged(nameof(Strategy));
}
}
}
public string SelectedSupplierDisplay => _selectedSupplier != null
? $"[{_selectedSupplier.SupplierCode}] {_selectedSupplier.SupplierName}"
: (string.IsNullOrWhiteSpace(Strategy?.SupplierName) ? "请选择供应商" : Strategy!.SupplierName!);
public bool HasSelectedSupplier =>
_selectedSupplier != null || !string.IsNullOrWhiteSpace(Strategy?.SupplierId);
private bool _result;
public bool Result { get => _result; set => SetProperty(ref _result, value); }
public Action? CloseAction { get; set; }
public DelegateCommand SaveCommand { get; }
public DelegateCommand CancelCommand { get; }
public DelegateCommand OpenMaterialPickerCommand { get; }
public DelegateCommand ClearMaterialCommand { get; }
public DelegateCommand OpenSupplierPickerCommand { get; }
public DelegateCommand ClearSupplierCommand { get; }
public MixerMaterialTareStrategyEditDialogViewModel(
IMixerMaterialTareStrategyService tareStrategyService,
IContainerExtension container,
IRegionManager regionManager) : base(container, regionManager)
{
_tareStrategyService = tareStrategyService;
SaveCommand = new DelegateCommand(async () => await SaveAsync());
CancelCommand = new DelegateCommand(() => CloseAction?.Invoke());
OpenMaterialPickerCommand = new DelegateCommand(async () => await OpenMaterialPickerAsync());
ClearMaterialCommand = new DelegateCommand(ClearMaterialSelection);
OpenSupplierPickerCommand = new DelegateCommand(async () => await OpenSupplierPickerAsync());
ClearSupplierCommand = new DelegateCommand(ClearSupplierSelection);
_ = LoadUnitsAsync();
}
private async Task LoadUnitsAsync()
{
try
{
var units = await _tareStrategyService.GetUnitsAsync();
UnitOptions.Clear();
foreach (var unit in units.Where(u => !string.IsNullOrWhiteSpace(u.Id)))
UnitOptions.Add(unit);
}
catch
{
UnitOptions.Clear();
}
}
public void InitializeForAdd()
{
Strategy = new MesXslMixerMaterialTareStrategy();
_selectedMaterial = null;
_selectedSupplier = null;
RaisePropertyChanged(nameof(IsAddMode));
RaisePropertyChanged(nameof(DialogTitle));
RaisePropertyChanged(nameof(SelectedMaterialDisplay));
RaisePropertyChanged(nameof(SelectedSupplierDisplay));
RaisePropertyChanged(nameof(HasSelectedMaterial));
RaisePropertyChanged(nameof(HasSelectedSupplier));
}
public void InitializeForEdit(MesXslMixerMaterialTareStrategy strategy)
{
Strategy = new MesXslMixerMaterialTareStrategy
{
Id = strategy.Id,
TenantId = strategy.TenantId,
MixerMaterialId = strategy.MixerMaterialId,
MixerMaterialName = strategy.MixerMaterialName,
SupplierId = strategy.SupplierId,
SupplierName = strategy.SupplierName,
MaterialSpec = strategy.MaterialSpec,
TareWeight = strategy.TareWeight,
PalletWeight = strategy.PalletWeight,
UnitId = strategy.UnitId,
UnitName = strategy.UnitName,
EffectiveStartDate = strategy.EffectiveStartDate,
EffectiveEndDate = strategy.EffectiveEndDate,
MaintainBy = strategy.MaintainBy,
UpdateTime = strategy.UpdateTime
};
_selectedMaterial = null;
_selectedSupplier = null;
RaisePropertyChanged(nameof(IsAddMode));
RaisePropertyChanged(nameof(DialogTitle));
RaisePropertyChanged(nameof(SelectedMaterialDisplay));
RaisePropertyChanged(nameof(SelectedSupplierDisplay));
RaisePropertyChanged(nameof(HasSelectedMaterial));
RaisePropertyChanged(nameof(HasSelectedSupplier));
}
private async Task OpenMaterialPickerAsync()
{
RawMaterialEntryMaterialPickerDialogViewModel? pickerVm = null;
bool confirmed;
try
{
confirmed = await HandyControl.Controls.Dialog.Show<RawMaterialEntryMaterialPickerDialogView>()
.Initialize<RawMaterialEntryMaterialPickerDialogViewModel>(vm =>
{
pickerVm = vm;
vm.Initialize(Strategy?.MixerMaterialId, Strategy?.MixerMaterialName);
})
.GetResultAsync<bool>();
}
catch { return; }
if (!confirmed || pickerVm?.SelectedMaterial == null) return;
SelectedMaterial = pickerVm.SelectedMaterial;
}
private void ClearMaterialSelection()
{
_selectedMaterial = null;
RaisePropertyChanged(nameof(SelectedMaterial));
RaisePropertyChanged(nameof(SelectedMaterialDisplay));
RaisePropertyChanged(nameof(HasSelectedMaterial));
if (Strategy == null) return;
Strategy.MixerMaterialId = null;
Strategy.MixerMaterialName = null;
RaisePropertyChanged(nameof(Strategy));
}
private async Task OpenSupplierPickerAsync()
{
SupplierPickerDialogViewModel? pickerVm = null;
bool confirmed;
try
{
confirmed = await HandyControl.Controls.Dialog.Show<SupplierPickerDialogView>()
.Initialize<SupplierPickerDialogViewModel>(vm => pickerVm = vm)
.GetResultAsync<bool>();
}
catch { return; }
if (!confirmed || pickerVm?.SelectedSupplier == null) return;
SelectedSupplier = pickerVm.SelectedSupplier;
}
private void ClearSupplierSelection()
{
_selectedSupplier = null;
RaisePropertyChanged(nameof(SelectedSupplier));
RaisePropertyChanged(nameof(SelectedSupplierDisplay));
RaisePropertyChanged(nameof(HasSelectedSupplier));
if (Strategy == null) return;
Strategy.SupplierId = null;
Strategy.SupplierName = null;
RaisePropertyChanged(nameof(Strategy));
}
private async Task SaveAsync()
{
if (Strategy == null) return;
if (string.IsNullOrWhiteSpace(Strategy.MixerMaterialId))
{
HandyControl.Controls.MessageBox.Warning("请选择密炼物料!");
return;
}
if (string.IsNullOrWhiteSpace(Strategy.SupplierId))
{
HandyControl.Controls.MessageBox.Warning("请选择供应商!");
return;
}
if (!Strategy.TareWeight.HasValue)
{
HandyControl.Controls.MessageBox.Warning("请填写包装物重量!");
return;
}
if (Strategy.PalletWeight.HasValue && Strategy.PalletWeight.Value < 0)
{
HandyControl.Controls.MessageBox.Warning("托盘重量不能为负数!");
return;
}
if (string.IsNullOrWhiteSpace(Strategy.UnitId))
{
HandyControl.Controls.MessageBox.Warning("请选择单位!");
return;
}
if (!Strategy.EffectiveStartDate.HasValue || !Strategy.EffectiveEndDate.HasValue)
{
HandyControl.Controls.MessageBox.Warning("请填写完整的生效日期!");
return;
}
if (Strategy.EffectiveStartDate.Value.Date > Strategy.EffectiveEndDate.Value.Date)
{
HandyControl.Controls.MessageBox.Warning("生效开始日期不能晚于截止日期!");
return;
}
var selectedUnit = UnitOptions.FirstOrDefault(u => string.Equals(u.Id, Strategy.UnitId, StringComparison.OrdinalIgnoreCase));
if (selectedUnit != null)
Strategy.UnitName = selectedUnit.UnitName;
Strategy.MaintainBy = AppSession.CurrentUser?.Account ?? Strategy.MaintainBy;
Strategy.MaterialSpec = string.IsNullOrWhiteSpace(Strategy.MaterialSpec)
? null
: Strategy.MaterialSpec.Trim();
try
{
bool ok;
if (IsAddMode)
{
ok = await _tareStrategyService.AddAsync(Strategy);
if (ok) HandyControl.Controls.MessageBox.Success("新增成功!");
else { HandyControl.Controls.MessageBox.Error("新增失败!"); return; }
}
else
{
ok = await _tareStrategyService.EditAsync(Strategy);
if (!ok) { HandyControl.Controls.MessageBox.Error("编辑失败!"); return; }
}
Result = ok;
CloseAction?.Invoke();
}
catch (Exception ex)
{
HandyControl.Controls.MessageBox.Error($"操作失败:{ex.Message}");
}
}
}

View File

@@ -0,0 +1,221 @@
using HandyControl.Controls;
using HandyControl.Tools.Extension;
using Prism.Events;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Windows;
using YY.Admin.Core;
using YY.Admin.Core.Entity;
using YY.Admin.Core.Events;
using YY.Admin.Core.Helper;
using YY.Admin.Core.Services;
using YY.Admin.Views.MixerMaterialTareStrategy;
namespace YY.Admin.ViewModels.MixerMaterialTareStrategy;
public class MixerMaterialTareStrategyListViewModel : BaseViewModel
{
private readonly IMixerMaterialTareStrategyService _tareStrategyService;
private SubscriptionToken? _changedToken;
private SubscriptionToken? _syncConflictToken;
private ObservableCollection<MesXslMixerMaterialTareStrategy> _strategies = new();
public ObservableCollection<MesXslMixerMaterialTareStrategy> Strategies
{
get => _strategies;
set => SetProperty(ref _strategies, value);
}
private long _total;
public long Total { get => _total; set => SetProperty(ref _total, value); }
private int _pageNo = 1;
public int PageNo { get => _pageNo; set => SetProperty(ref _pageNo, value); }
private int _pageSize = 20;
public int PageSize { get => _pageSize; set => SetProperty(ref _pageSize, value); }
private string? _filterMixerMaterialName;
public string? FilterMixerMaterialName
{
get => _filterMixerMaterialName;
set => SetProperty(ref _filterMixerMaterialName, value);
}
private string? _filterSupplierName;
public string? FilterSupplierName
{
get => _filterSupplierName;
set => SetProperty(ref _filterSupplierName, value);
}
public DelegateCommand SearchCommand { get; }
public DelegateCommand ResetCommand { get; }
public DelegateCommand AddCommand { get; }
public DelegateCommand<MesXslMixerMaterialTareStrategy> EditCommand { get; }
public DelegateCommand<MesXslMixerMaterialTareStrategy> DeleteCommand { get; }
public DelegateCommand PrevPageCommand { get; }
public DelegateCommand NextPageCommand { get; }
public MixerMaterialTareStrategyListViewModel(
IMixerMaterialTareStrategyService tareStrategyService,
IContainerExtension container,
IRegionManager regionManager) : base(container, regionManager)
{
_tareStrategyService = tareStrategyService;
SearchCommand = new DelegateCommand(async () => { PageNo = 1; await LoadAsync(); });
ResetCommand = new DelegateCommand(async () =>
{
FilterMixerMaterialName = null;
FilterSupplierName = null;
PageNo = 1;
await LoadAsync();
});
AddCommand = new DelegateCommand(async () => await ShowAddDialogAsync());
EditCommand = new DelegateCommand<MesXslMixerMaterialTareStrategy>(async s => await ShowEditDialogAsync(s));
DeleteCommand = new DelegateCommand<MesXslMixerMaterialTareStrategy>(async s => await DeleteAsync(s));
PrevPageCommand = new DelegateCommand(async () => { if (PageNo > 1) { PageNo--; await LoadAsync(); } });
NextPageCommand = new DelegateCommand(async () => { if ((long)PageNo * PageSize < Total) { PageNo++; await LoadAsync(); } });
_changedToken = _eventAggregator.GetEvent<MixerMaterialTareStrategyChangedEvent>()
.Subscribe(async p => await OnChangedAsync(p), ThreadOption.UIThread);
_syncConflictToken = _eventAggregator.GetEvent<SyncConflictEvent>()
.Subscribe(OnSyncConflict, ThreadOption.UIThread);
_ = InitializeAsync();
}
private async Task OnChangedAsync(MixerMaterialTareStrategyChangedPayload payload)
{
if (payload.Action == "edit" && !string.IsNullOrWhiteSpace(payload.TareStrategyId))
await RefreshSingleAsync(payload.TareStrategyId!);
else
await LoadAsync();
}
private async Task RefreshSingleAsync(string id)
{
try
{
var updated = await _tareStrategyService.GetByIdAsync(id);
if (updated == null) return;
var idx = Strategies.ToList().FindIndex(s => string.Equals(s.Id, id, StringComparison.OrdinalIgnoreCase));
if (idx >= 0) Strategies[idx] = updated;
}
catch (Exception ex)
{
Debug.WriteLine($"[密炼物料皮重策略] 单条刷新失败: {ex.Message}");
}
}
private void OnSyncConflict(SyncConflictPayload payload)
{
if (!string.Equals(payload.EntityName, "密炼物料皮重策略", StringComparison.OrdinalIgnoreCase)) return;
var parts = new List<string>();
if (payload.PushedCount > 0)
parts.Add($"已同步 {payload.PushedCount} 条本地改动到服务器");
if (payload.NewRecordsPushed > 0)
parts.Add($"已上传 {payload.NewRecordsPushed} 条本地新增记录");
if (payload.ConflictCount > 0)
parts.Add($"{payload.ConflictCount} 条记录与服务器版本冲突,已保留服务器版本");
if (parts.Count == 0) return;
var message = string.Join("\n", parts);
if (payload.ConflictCount > 0) Growl.Warning(message);
else Growl.Success(message);
}
private async Task InitializeAsync()
{
try
{
await UIHelper.WaitForRenderAsync();
await LoadAsync();
}
catch (Exception ex)
{
Debug.WriteLine($"密炼物料皮重策略列表初始化失败: {ex.Message}");
}
}
public async Task LoadAsync()
{
try
{
IsLoading = true;
var result = await _tareStrategyService.PageAsync(
PageNo, PageSize, FilterMixerMaterialName, FilterSupplierName);
Strategies = new ObservableCollection<MesXslMixerMaterialTareStrategy>(result.Records);
Total = result.Total;
}
catch (Exception ex)
{
Growl.Error($"加载密炼物料皮重策略失败:{ex.Message}");
}
finally
{
IsLoading = false;
}
}
private async Task ShowAddDialogAsync()
{
try
{
var result = await HandyControl.Controls.Dialog.Show<MixerMaterialTareStrategyEditDialogView>()
.Initialize<MixerMaterialTareStrategyEditDialogViewModel>(vm => vm.InitializeForAdd())
.GetResultAsync<bool>();
if (result) await LoadAsync();
}
catch (Exception ex)
{
Growl.Error($"打开新增对话框失败:{ex.Message}");
}
}
private async Task ShowEditDialogAsync(MesXslMixerMaterialTareStrategy strategy)
{
if (strategy == null) return;
try
{
var result = await HandyControl.Controls.Dialog.Show<MixerMaterialTareStrategyEditDialogView>()
.Initialize<MixerMaterialTareStrategyEditDialogViewModel>(vm => vm.InitializeForEdit(strategy))
.GetResultAsync<bool>();
if (result) await LoadAsync();
}
catch (Exception ex)
{
Growl.Error($"打开编辑对话框失败:{ex.Message}");
}
}
private async Task DeleteAsync(MesXslMixerMaterialTareStrategy strategy)
{
if (strategy?.Id == null) return;
var confirm = System.Windows.MessageBox.Show(
$"确定删除【{strategy.MixerMaterialName} / {strategy.SupplierName}】的包装物重量策略?此操作不可恢复!",
"确认删除", MessageBoxButton.OKCancel, MessageBoxImage.Question);
if (confirm != System.Windows.MessageBoxResult.OK) return;
var ok = await _tareStrategyService.DeleteAsync(strategy.Id);
if (ok) { Growl.Success("删除成功!"); await LoadAsync(); }
else Growl.Error("删除失败!");
}
protected override void CleanUp()
{
base.CleanUp();
if (_changedToken != null)
{
_eventAggregator.GetEvent<MixerMaterialTareStrategyChangedEvent>().Unsubscribe(_changedToken);
_changedToken = null;
}
if (_syncConflictToken != null)
{
_eventAggregator.GetEvent<SyncConflictEvent>().Unsubscribe(_syncConflictToken);
_syncConflictToken = null;
}
}
}