1、功能介绍
当选择一个空桌时，必须先开台才能开单，可以先开台，再开单，也可以开台的同时开单
当选择一个用餐中的餐桌时，必须显示该桌前面已经点好的菜品，同时可以继续点餐或结账
所以无论哪个功能都涉及选择菜品的操作，也就是选择不同类型的商品
2、UI设计
这些数字0--9它们都是绑定同一个命令，但是命令处理时，会根据不同参数来区分是哪个按钮被点击了，所以就有CommandParameter="{Binding RelativeSource={RelativeSource Self}}"，它表示绑定的参数是自己
3、视图模型
完整代码
using HQ.BLL;
using HQ.COMM;
using HQ.fResApp.BaseModel;
using HQ.MODEL.DBModel;
using Panuon.UI.Silver;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows;
using HQ.fResApp.Utils;
using HQ.MODEL.UIModel;
using System.Windows.Input;
using System.Globalization;
using Panuon.UI.Silver.Core;
namespace HQ.fResApp.ViewModel
{
/// <summary>
/// 消费开单视图模型
/// </summary>
public class XiaoFeiKaiDanListVModel : ViewModelBase
{
public DiningTypeBLL diningbll = new DiningTypeBLL();//餐桌类型
public DiningTableBLL tablebll = new DiningTableBLL();//餐台列表
public DishTypeBLL dishbll = new DishTypeBLL();//菜品类型
public PointMenuBLL menubll = new PointMenuBLL();//菜品列表
public BillConsumeBLL billConsumebll = new BillConsumeBLL();//帐单消费列表
public BillHistoryBLL billHistorybll = new BillHistoryBLL();//订单历史记录
public ListBox dishListBox { get; set; }//菜品列表ListBox控件对象
public Dictionary<string, ListBox> DicdishListBox = new Dictionary<string, ListBox>();
public PointMenuInfo selectDishItem = new PointMenuInfo();
public double CostMoney = 0;
public string globalGuid = "";//菜品类型
public List<ListBoxItem> selectedItem = new List<ListBoxItem>();
/// <summary>
/// 用户点击选择菜品时生成的订单信息表
/// </summary>
List<PointMenuInfo> OrderInfoTable = new List<PointMenuInfo>();
#region 属性
private ObservableCollection<TabItem> diningTypeList;
/// <summary>
/// 餐桌类型列表，页面tabcontrol绑定的数据源
/// </summary>
public ObservableCollection<TabItem> DiningTypeList
{
get { return diningTypeList; }
set
{
diningTypeList = value;
OnPropertyChanged();
}
}
private Visibility diningTypeTabPro = Visibility.Visible;
/// <summary>
/// 餐桌类型tabcontrol是否可见
/// </summary>
public Visibility DiningTypeTabPro
{
get { return diningTypeTabPro; }
set
{
diningTypeTabPro = value;
OnPropertyChanged();
}
}
private Visibility diningTableListPro = Visibility.Visible;
/// <summary>
/// 餐桌列表是否可见
/// </summary>
public Visibility DiningTableListPro
{
get { return diningTableListPro; }
set
{
diningTableListPro = value;
OnPropertyChanged();
}
}
private ObservableCollection<DiningTableDetail> diningTableList;
/// <summary>
///餐桌详情列表
/// </summary>
public ObservableCollection<DiningTableDetail> DiningTableList
{
get { return diningTableList; }
set
{
diningTableList = value;
OnPropertyChanged();
}
}
private ObservableCollection<PointMenuInfo> dishTableList;
/// <summary>
/// 菜品名称列表，页面listbox绑定的数据源
/// </summary>
public ObservableCollection<PointMenuInfo> DishTableList
{
get { return dishTableList; }
set
{
dishTableList = value;
OnPropertyChanged();
}
}
private ObservableCollection<PointMenuInfo> addOrderInfoList = new ObservableCollection<PointMenuInfo>();
/// <summary>
/// 【继续点餐】后新增的订单或空桌开台【开始点餐】后添加的订单
/// </summary>
public ObservableCollection<PointMenuInfo> AddOrderInfoList
{
get { return addOrderInfoList; }
set
{
addOrderInfoList = value;
OnPropertyChanged();
}
}
private ObservableCollection<TableConsumeInfo> tableConsumeList;
/// <summary>
/// 餐桌消费详情列表
/// </summary>
public ObservableCollection<TableConsumeInfo> TableConsumeList
{
get { return tableConsumeList; }
set
{
tableConsumeList = value;
OnPropertyChanged();
}
}
private PointMenuInfo dishNameItem = new PointMenuInfo();
/// <summary>
/// 所选的菜品名称
/// </summary>
public PointMenuInfo DishNameItem
{
get { return dishNameItem; }
set
{
dishNameItem = value;
OnPropertyChanged();
}
}
private DiningTableDetail diningTableItem = new DiningTableDetail();
/// <summary>
/// 餐桌详情实体
/// </summary>
public DiningTableDetail DiningTableItem
{
get { return diningTableItem; }
set
{
diningTableItem = value;
OnPropertyChanged();
}
}
private DiningType diningTypeItem = new DiningType();
/// <summary>
/// 餐桌类型
/// </summary>
public DiningType DiningTypeItem
{
get { return diningTypeItem; }
set
{
diningTypeItem = value;
OnPropertyChanged();
}
}
private DishType dishTypeItem = new DishType();
/// <summary>
/// 菜品类型
/// </summary>
public DishType DishTypeItem
{
get { return dishTypeItem; }
set
{
dishTypeItem = value;
OnPropertyChanged();
}
}
private Visibility tabConsumeHeadPro = Visibility.Collapsed;
/// <summary>
/// 已开单餐桌的【消费项目】表头标题是否可见
/// </summary>
public Visibility TabConsumeHeadPro
{
get { return tabConsumeHeadPro; }
set
{
tabConsumeHeadPro = value;
OnPropertyChanged();
}
}
private Visibility tabConsumeListPro = Visibility.Collapsed;
/// <summary>
/// 已开单餐桌的消费明细列表是否可见
/// </summary>
public Visibility TabConsumeListPro
{
get { return tabConsumeListPro; }
set
{
tabConsumeListPro = value;
OnPropertyChanged();
}
}
private Visibility costSumInfoPro = Visibility.Collapsed;
/// <summary>
/// 消费项目汇总信息是否可见
/// </summary>
public Visibility CostSumInfoPro
{
get { return costSumInfoPro; }
set
{
costSumInfoPro = value;
OnPropertyChanged();
}
}
private ObservableCollection<TabItem> dishTypeList;
/// <summary>
/// 菜品类型列表，页面tabcontrol绑定的数据源
/// </summary>
public ObservableCollection<TabItem> DishTypeList
{
get { return dishTypeList; }
set
{
dishTypeList = value;
OnPropertyChanged();
}
}
private Visibility goodsTypeTabPro = Visibility.Collapsed;
/// <summary>
/// 菜品类型选项卡是否可见
/// </summary>
public Visibility GoodsTypeTabPro
{
get { return goodsTypeTabPro; }
set
{
goodsTypeTabPro = value;
OnPropertyChanged();
}
}
private Visibility goodsListBoxPro = Visibility.Collapsed;
/// <summary>
/// 菜品类型列表框是否可见
/// </summary>
public Visibility GoodsListBoxPro
{
get { return goodsListBoxPro; }
set
{
goodsListBoxPro = value;
OnPropertyChanged();
}
}
private Visibility btnPaymentPro = Visibility.Collapsed;
/// <summary>
/// 【结帐】按钮是否可见
/// </summary>
public Visibility BtnPaymentPro
{
get { return btnPaymentPro; }
set
{
btnPaymentPro = value;
OnPropertyChanged();
}
}
private Visibility openOrderInfoPro = Visibility.Collapsed;
/// <summary>
/// 空桌准备开单的详情是否可见
/// </summary>
public Visibility OpenOrderInfoPro
{
get { return openOrderInfoPro; }
set
{
openOrderInfoPro = value;
OnPropertyChanged();
}
}
private Visibility openTableInfoPro = Visibility.Visible;
/// <summary>
/// 空桌需要开台的详情是否可见
/// </summary>
public Visibility OpenTableInfoPro
{
get { return openTableInfoPro; }
set
{
openTableInfoPro = value;
OnPropertyChanged();
}
}
private string tableOrderNoPro = "xxxxxx";
/// <summary>
/// 餐桌订单号
/// </summary>
public string TableOrderNoPro
{
get { return tableOrderNoPro; }
set
{
tableOrderNoPro = value;
OnPropertyChanged();
}
}
private string tableNamePro = "xxx";
/// <summary>
/// 餐桌名称
/// </summary>
public string TableNamePro
{
get { return tableNamePro; }
set
{
tableNamePro = value;
OnPropertyChanged();
}
}
private string amountUser = "";
/// <summary>
/// 用餐人数
/// </summary>
public string AmountUser
{
get { return amountUser; }
set
{
amountUser = value;
OnPropertyChanged();
}
}
private string amountTime = "";
/// <summary>
/// 用餐时间
/// </summary>
public string AmountTime
{
get { return amountTime; }
set
{
amountTime = value;
OnPropertyChanged();
}
}
private string numOrderPro = "";
/// <summary>
/// 输入就餐人数
/// </summary>
public string NumOrderPro
{
get { return numOrderPro; }
set
{
numOrderPro = value;
OnPropertyChanged();
}
}
private string amountMoneyPro = "";
/// <summary>
/// 消费总金额
/// </summary>
public string AmountMoneyPro
{
get { return amountMoneyPro; }
set
{
amountMoneyPro = value;
OnPropertyChanged();
}
}
private string amountCountPro = "";
/// <summary>
/// 消费总数量
/// </summary>
public string AmountCountPro
{
get { return amountCountPro; }
set
{
amountCountPro = value;
OnPropertyChanged();
}
}
private string tableTypePro = "xxxx";
/// <summary>
/// 餐桌类型
/// </summary>
public string TableTypePro
{
get { return tableTypePro; }
set
{
tableTypePro = value;
OnPropertyChanged();
}
}
private string txtTabControlTitle = "餐桌类型";
/// <summary>
/// tabcontrol标题
/// </summary>
public string TxtTabControlTitle
{
get { return txtTabControlTitle; }
set
{
txtTabControlTitle = value;
OnPropertyChanged();
}
}
private string txtTabControlName = "餐桌面板";
/// <summary>
/// tabcontrol标题
/// </summary>
public string TxtTabControlName
{
get { return txtTabControlName; }
set
{
txtTabControlName = value;
OnPropertyChanged();
}
}
private Visibility dishTypeTabPro = Visibility.Collapsed;
/// <summary>
/// 菜品类型tabcontrol是否可见
/// </summary>
public Visibility DishTypeTabPro
{
get { return dishTypeTabPro; }
set
{
dishTypeTabPro = value;
OnPropertyChanged();
}
}
private Visibility dishTypeListPro = Visibility.Collapsed;
/// <summary>
/// 菜品列表ListBox是否可见
/// </summary>
public Visibility DishTypeListPro
{
get { return dishTypeListPro; }
set
{
dishTypeListPro = value;
OnPropertyChanged();
}
}
private string txtCostMonePro = "";
/// <summary>
/// 点单金额
/// </summary>
public string TxtCostMonePro
{
get { return txtCostMonePro; }
set
{
txtCostMonePro = value;
OnPropertyChanged();
}
}
private string txtCostCountPro = "";
/// <summary>
/// 点单数量
/// </summary>
public string TxtCostCountPro
{
get { return txtCostCountPro; }
set
{
txtCostCountPro = value;
OnPropertyChanged();
}
}
private Visibility proNumBlockPro2 = Visibility.Collapsed;
/// <summary>
/// 选中菜品时的图片是否可见
/// </summary>
public Visibility ProNumBlockPro2
{
get { return proNumBlockPro2; }
set
{
proNumBlockPro2 = value;
OnPropertyChanged();
}
}
private Visibility checkOutPro = Visibility.Collapsed;
/// <summary>
/// 结账或继续点餐按钮是否可见
/// </summary>
public Visibility CheckOutPro
{
get { return checkOutPro; }
set
{
checkOutPro = value;
OnPropertyChanged();
}
}
private Visibility checkOutPro2 = Visibility.Collapsed;
/// <summary>
/// 消费时长及消费人数的stackpanel控件是否可见
/// </summary>
public Visibility CheckOutPro2
{
get { return checkOutPro2; }
set
{
checkOutPro2 = value;
OnPropertyChanged();
}
}
private string dinersPro = "";
/// <summary>
/// 输入就餐人数
/// </summary>
public string DinersPro
{
get { return dinersPro; }
set
{
dinersPro = value;
OnPropertyChanged();
}
}
private string tableTxtRemarkPro = "";
/// <summary>
/// 立即开台操作时的备注信息
/// </summary>
public string TableTxtRemarkPro
{
get { return tableTxtRemarkPro; }
set
{
tableTxtRemarkPro = value;
OnPropertyChanged();
}
}
private bool chkIsOrderDetailPro = false;
/// <summary>
/// 开单后是否立即新增消费项目
/// </summary>
public bool ChkIsOrderDetailPro
{
get { return chkIsOrderDetailPro; }
set
{
chkIsOrderDetailPro = value;
OnPropertyChanged();
}
}
private string startDinerPro = "继续点餐";
/// <summary>
/// 开始点餐还是继续点餐按钮上的文字
/// </summary>
public string StartDinerPro
{
get { return startDinerPro; }
set
{
startDinerPro = value;
OnPropertyChanged();
}
}
private Thickness tabConsumeHeadMarginPro = new Thickness(0, 0, 0, 0);
/// <summary>
/// 已经开单餐桌的消费列表中标题栏控件的margin设置
/// </summary>
public Thickness TabConsumeHeadMarginPro
{
get { return tabConsumeHeadMarginPro; }
set
{
tabConsumeHeadMarginPro = value;
OnPropertyChanged();
}
}
private Thickness tableConsumeListMarginPro = new Thickness(0, 0, 0, 0);
/// <summary>
/// 已经开单餐桌的消费列表中listbox控件的margin设置
/// </summary>
public Thickness TableConsumeListMarginPro
{
get { return tableConsumeListMarginPro; }
set
{
tableConsumeListMarginPro = value;
OnPropertyChanged();
}
}
private string tableConsumeListHeightPro = "auto";
/// <summary>
/// 已经开单餐桌的消费列表中listbox控件的高度设置
/// </summary>
public string TableConsumeListHeightPro
{
get { return tableConsumeListHeightPro; }
set
{
tableConsumeListHeightPro = value;
OnPropertyChanged();
}
}
#endregion
public XiaoFeiKaiDanListVModel()
{
DiningTypeList = getDiningTypeList(); //餐桌类型
DiningTableList = getDiningTableList(); //餐台列表
}
#region 方法
/// <summary>
/// 获取菜品类型
/// </summary>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
private ObservableCollection<TabItem> getDishTypeList()
{
ObservableCollection<TabItem> typeitemlist = new ObservableCollection<TabItem>();
TabItem _ti = new TabItem()
{
Header = "所有菜品",
Uid = "",
Margin = new Thickness { Left = 0, Top = 0, Right = 10, Bottom = 0 },
Padding = new Thickness { Left = 25, Right = 30, Top = 5, Bottom = 5 }
};
typeitemlist.Add(_ti);
var parms = new ParmString { parm = "" };
var _dishTypeRes = dishbll.QueryDishTypeList(parms).Result;
if (_dishTypeRes.statusCode == (int)ApiEnum.Status)
{
var prots = _dishTypeRes.data;
if (prots != null)
{
foreach (var _typeObj in prots)
{
var bgc = new BrushConverter();
TabItem ti = new TabItem()
{
Header = _typeObj.mtName,
Uid = _typeObj.mtGuid.ToString(),
Margin = new Thickness { Left = 0, Top = 0, Right = 10, Bottom = 0 },
Padding = new Thickness { Left = 25, Right = 30, Top = 5, Bottom = 5 }
};
typeitemlist.Add(ti);
}
}
}
else
{
Logger.Default.ProcessError(_dishTypeRes.statusCode, "获取菜单类型异常");
}
return typeitemlist;
}
/// <summary>
/// 获取菜品列表
/// </summary>
/// <param name="protype">菜品类型id</param>
/// <returns></returns>
private ObservableCollection<PointMenuInfo> getDishTableList(string protype)
{
ObservableCollection<PointMenuInfo> TableDataList = new ObservableCollection<PointMenuInfo>();
var _parms = new ParmString { parm = protype };
var _res = menubll.QueryPointMenusBydtId(_parms).Result;
if (_res.statusCode == (int)ApiEnum.Status)
{
var _datas = _res.data;
if (_datas != null)
{
foreach (PointMenuInfo item in _datas)
{
TableDataList.Add(item);
}
}
}
else
{
Notice.Show("没有找到对应的菜品", "提示", 3, MessageBoxIcon.Info);
Logger.Default.ProcessError(_res.statusCode, "根据商品类型获取商品异常");
}
return TableDataList;
}
/// <summary>
/// 获取餐桌类型
/// </summary>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public ObservableCollection<TabItem> getDiningTypeList()
{
ObservableCollection<TabItem> typeitemlist = new ObservableCollection<TabItem>();
TabItem _ti = new TabItem()
{
Header = "所有餐台",
Margin = new Thickness { Left = 0, Top = 0, Right = 10, Bottom = 0 },
Padding = new Thickness { Left = 25, Right = 30, Top = 5, Bottom = 5 }
};
typeitemlist.Add(_ti);
var _parm = new ParmString { parm = "" };
var _tabRest = diningbll.QueryDiningTypeList(_parm).Result;
if (_tabRest.statusCode == (int)ApiEnum.Status)
{
var _roomTypes = _tabRest.data;
if (_roomTypes != null)
{
foreach (var diningTypeObj in _roomTypes)
{
var bgc = new BrushConverter();
TabItem ti = new TabItem()
{
Header = diningTypeObj.rtName,
Margin = new Thickness { Left = 0, Top = 0, Right = 10, Bottom = 0 },
Padding = new Thickness { Left = 25, Right = 30, Top = 5, Bottom = 5 }
};
typeitemlist.Add(ti);
}
}
}
return typeitemlist;
}
/// <summary>
/// 获取餐桌列表
/// </summary>
/// <param name="strWhere">过滤条件</param>
/// <param name="_rtId">餐桌类型</param>
/// <returns></returns>
public ObservableCollection<DiningTableDetail> getDiningTableList(string rtid = "", int rtstate = -1)
{
ObservableCollection<DiningTableDetail> TableDataList = new ObservableCollection<DiningTableDetail>();
var parms = new PageParm { diningtypeId = rtid, types = rtstate };
var _tabRes = tablebll.QueryListByType(parms).Result;
if (_tabRes.statusCode == (int)ApiEnum.Status)
{
var tables = _tabRes.data;
if (tables != null)
{
foreach (var roomObj in tables)
{
var _time = "0分钟";
if (roomObj.rtDate != null)
{
_time = DateHelper.DateDiffMinutes(DateTime.Now, Convert.ToDateTime(roomObj.rtDate));
}
var _tbState = "#cccccc";
var _tbStateName = "空闲";
switch (roomObj.rtState)
{
case "占用":
_tbState = "#C800AAFF";
_tbStateName = "用餐中";
break;
case "预定":
_tbState = "green";
_tbStateName = "预约中";
_time = "0分钟";
break;
case "脏台":
_tbState = "red";
_tbStateName = "待清理";
_time = "0分钟";
break;
case "停用":
_tbState = "black";
_tbStateName = "已停用";
_time = "0分钟";
break;
}
var _obj = new DiningTableDetail()
{
rtId = roomObj.rtId,
rtName = roomObj.rtName,
tbName = roomObj.rName,
tbMaxNum = roomObj.rtNumber != null ? (int)roomObj.rtNumber : 0,
userTime = _time,
tbStateColor = _tbState,
tbStateName = _tbStateName,
tbId = roomObj.rbGuid,
tbOrderNo = roomObj.obId
};
TableDataList.Add(_obj);
}
}
}
else
{
Notice.Show("系统连接失败，请联系您的管理员！", "提示", 3, MessageBoxIcon.Warning);
Logger.Default.ProcessError(_tabRes.statusCode, "没有获取餐桌类型对应的所有餐台");
}
return TableDataList;
}
/// <summary>
/// 获取单个餐桌的消费详情
/// </summary>
/// <param name="strOrder">订单号</param>
private ObservableCollection<TableConsumeInfo> GetDeskConsumeDetail(string strOrder)
{
ObservableCollection<TableConsumeInfo> consumeList = new ObservableCollection<TableConsumeInfo>();
try
{
double _msMoney = 0;
int amountCount = 0;
double tMoney = 0;
var parms = new ParmString { parm = strOrder };
var _tabInfoRes = tablebll.GetTabCostdetails(parms).Result;
if (_tabInfoRes.statusCode == (int)ApiEnum.Status)
{
List<TableConsumeInfo> TableDetailList = _tabInfoRes.data;
if (TableDetailList != null)
{
BtnPaymentPro = Visibility.Visible;//结算按钮可见
foreach (var item in TableDetailList)
{
tMoney = item.msPrice * item.msAmount;
_msMoney = _msMoney + tMoney;
amountCount = amountCount + item.msAmount;
consumeList.Add(item);
}
StartDinerPro = "继续点餐";
}
else
{
BtnPaymentPro = Visibility.Collapsed;//结算按钮隐藏
StartDinerPro = "开始点餐";
}
AmountMoneyPro = _msMoney.ToString();//消费总金额
AmountCountPro = amountCount.ToString();//消费总数量
}
else
{
Logger.Default.ProcessError(_tabInfoRes.statusCode, "获取单个餐桌消费详情出现异常");
}
}
catch (Exception ex)
{
Notice.Show("查询失败！", "提示", 3, MessageBoxIcon.Warning);
Logger.Default.Error("获取单个餐桌消费详情出现异常", ex);
}
return consumeList;
}
/// <summary>
/// 结帐后刷新界面
/// </summary>
private void RefreshPage()
{
DiningTableList = getDiningTableList(); //餐台列表更新
OrderInfoTable = new List<PointMenuInfo>();//清空帐单
DinersPro = "";//就餐人數清空
TableNamePro = "xxxx";//餐桌名稱
TableTypePro = "xxxx";//餐桌類型
TableOrderNoPro = "0000000000";//餐桌訂單號
ChkIsOrderDetailPro = false;//开单后立即新增消费项目复选框
OpenOrderInfoPro = Visibility.Collapsed;//空闲餐桌需要准备"开单"的详情隱藏
DishTypeListPro = Visibility.Collapsed;//菜品列表隱藏
DishTypeTabPro = Visibility.Collapsed;//菜品類型隱藏
TabConsumeHeadPro = Visibility.Collapsed;//已经开单餐桌的消费清单详情，包括：标题栏，数据列，分隔线，汇总
TabConsumeListPro = Visibility.Collapsed;
CostSumInfoPro = Visibility.Collapsed;
OpenTableInfoPro = Visibility.Visible;//空闲餐桌需要"开台"的详情顯示
DiningTypeTabPro = Visibility.Visible;//餐桌類型顯示
DiningTableListPro = Visibility.Visible;//餐桌列表顯示
}
private childItem FindVisualChild<childItem>(DependencyObject obj) where childItem : DependencyObject
{
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(obj, i);
if (child != null && child is childItem)
{
return (childItem)child;
}
else
{
childItem childOfChild = FindVisualChild<childItem>(child);
if (childOfChild != null)
return childOfChild;
}
}
return null;
}
/// <summary>
/// 利用VisualTreeHelper寻找指定依赖对象的父级对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static List<T> FindVisualParent<T>(DependencyObject obj) where T : DependencyObject
{
try
{
List<T> TList = new List<T> { };
DependencyObject parent = VisualTreeHelper.GetParent(obj);
if (parent != null && parent is T)
{
TList.Add((T)parent);
List<T> parentOfParent = FindVisualParent<T>(parent);
if (parentOfParent != null)
{
TList.AddRange(parentOfParent);
}
}
else if (parent != null)
{
List<T> parentOfParent = FindVisualParent<T>(parent);
if (parentOfParent != null)
{
TList.AddRange(parentOfParent);
}
}
return TList;
}
catch (Exception ee)
{
MessageBox.Show(ee.Message);
return null;
}
}
/// <summary>
/// 搜索指定名称的子元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="name"></param>
/// <returns></returns>
public static T FindChild<T>(DependencyObject obj, string name) where T : FrameworkElement
{
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
{
DependencyObject child = VisualTreeHelper.GetChild(obj, i);
if (child != null && child is T && (child as T).Name.Equals(name))
return (T)child;
else
{
T childOfChild = FindChild<T>(child, name);
if (childOfChild != null)
return childOfChild;
}
}
return null;
}
/// <summary>
/// 寻找某个控件的父级控件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="name"></param>
/// <returns></returns>
public T GetParentObject<T>(DependencyObject obj, string name) where T : FrameworkElement
{
DependencyObject parent = VisualTreeHelper.GetParent(obj);
while (parent != null)
{
if (parent is T && (((T)parent).Name == name | string.IsNullOrEmpty(name)))
{
return (T)parent;
}
parent = VisualTreeHelper.GetParent(parent);
}
return null;
}
/// <summary>
/// 寻找子控件
/// </summary>
/// <typeparam name="childItem"></typeparam>
/// <param name="obj">父级控件</param>
/// <param name="ctrtype">子控件类型名</param>
/// <returns></returns>
private object FindChildCtr<childItem>(DependencyObject obj, string ctrtype) where childItem : DependencyObject
{
var _childLen = VisualTreeHelper.GetChildrenCount(obj);
for (int i = 0; i < _childLen; i++)
{
DependencyObject child = VisualTreeHelper.GetChild(obj, i);
if (child != null && child.DependencyObjectType.SystemType.Name == ctrtype)
{
return child;
}
}
return null;
}
#endregion
#region 命令
/// <summary>
/// 餐桌类型点击切换命令(tabcontrol)
/// </summary>
public ICommand SelectDiningCommand
{
get
{
return new RelayCommand(o =>
{
if (o is TabControl)
{
TabControl diningtab = o as TabControl;
int index = diningtab.SelectedIndex;
if (index == -1)
{
diningtab.SelectedIndex = 0;
}
var tt = (o as TabControl).SelectedItem as TabItem;
string strName = tt.Header.ToString();//获取餐桌类型名称
//根据名称获取餐桌类型实体
var _queryRes = diningbll.GetModel(" rtName='" + strName + "' ").Result;
if (_queryRes.statusCode == (int)ApiEnum.Status)
{
var diningTypeObj = _queryRes.data;
var _diningTypeId = diningTypeObj != null ? diningTypeObj.rtGuid : string.Empty;
var _rtstate = diningTypeObj != null && _diningTypeId != null ? 5 : -1;
//根据餐桌类型获取对应的餐台列表
DiningTableList = getDiningTableList(_diningTypeId, _rtstate);
}
}
});
}
}
/// <summary>
/// 餐桌点击命令(listbox)
/// </summary>
public ICommand SelectTableCommand
{
get
{
return new RelayCommand(o =>
{
if (o is ListBox)
{
var obj = DiningTableItem;
if (DiningTableItem != null)
{
TableOrderNoPro = DiningTableItem.tbOrderNo;//餐台订单号
TableNamePro = DiningTableItem.tbName;//餐台名称
AmountUser = DiningTableItem.tbMaxNum.ToString();//就餐人数
AmountTime = DiningTableItem.userTime.Replace("分钟", "");//用餐时间
NumOrderPro = DiningTableItem.tbMaxNum.ToString();//输入的就餐人数
TableTypePro = DiningTableItem.rtName.ToString();//餐台类型名称
switch (DiningTableItem.tbStateName)
{
case "用餐中":
TabConsumeHeadPro = Visibility.Visible;//消费项目
TabConsumeListPro = Visibility.Visible;//消费明细
CostSumInfoPro = Visibility.Visible;//消费汇总
OpenTableInfoPro = Visibility.Collapsed;//开台面板隐藏
break;
case "空闲":
OpenTableInfoPro = Visibility.Visible;
TabConsumeHeadPro = Visibility.Collapsed;
TabConsumeListPro = Visibility.Collapsed;
CostSumInfoPro = Visibility.Collapsed;
TableOrderNoPro = "还没有创建订单";
break;
case "预约中":
OpenTableInfoPro = Visibility.Visible;
TabConsumeHeadPro = Visibility.Collapsed;
TabConsumeListPro = Visibility.Collapsed;
CostSumInfoPro = Visibility.Collapsed;
TableOrderNoPro = "还没有创建订单";
break;
case "待清理":
OpenTableInfoPro = Visibility.Visible;
TabConsumeHeadPro = Visibility.Collapsed;
TabConsumeListPro = Visibility.Collapsed;
CostSumInfoPro = Visibility.Collapsed;
break;
case "已停用":
Notice.Show("当前餐桌已停用，请选择其他可用餐桌！", "提示", 3, MessageBoxIcon.Warning);
break;
}
TableConsumeList = GetDeskConsumeDetail(TableOrderNoPro);//根据订单号获取单个餐台的消费详情
TableConsumeListMarginPro = new Thickness(0, 0, 0, 0);
TabConsumeHeadMarginPro = new Thickness(0, 0, 0, 0);
TableConsumeListHeightPro = "500";
CheckOutPro = Visibility.Visible;
}
}
});
}
}
/// <summary>
/// 菜品类型点击切换命令(tabcontrol)
/// </summary>
public ICommand SelectMenuCommand
{
get
{
return new RelayCommand(o =>
{
if (o is TabControl)
{
TabControl control = o as TabControl;
var _curTabItem = control.SelectedItem as TabItem;
if (_curTabItem == null)
{
control.SelectedIndex = 0;
return;
}
var _mtguid = _curTabItem.Uid != null ? _curTabItem.Uid.ToString() : "";
DishTableList = getDishTableList(_mtguid);
globalGuid = _mtguid;
if (dishListBox == null)
{
return;
}
//此问题待解决
//Dispatcher.CurrentDispatcher.Invoke(new Action(() =>
//{
// ListBoxItem a1 = new ListBoxItem();
// var a2 = dishListBox.ItemContainerGenerator;
// for (int i = 0; i < dishListBox.Items.Count; i++)
// {
// if (a2.ContainerFromIndex(i) is ListBoxItem)
// {
// a1 = a2.ContainerFromIndex(i) as ListBoxItem;
// var c0 = selectedItem[0];
// ////寻找指定的控件，即ProNumBlock控件
// ContentPresenter myContentPresenter = FindChildControlUtil.FindVisualChild<ContentPresenter>(a1);
// DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
// StackPanel _proNumBlock = (StackPanel)myDataTemplate.FindName("ProNumBlock", myContentPresenter);
// if (_proNumBlock.IsVisible)//取消选中菜品
// {
// _proNumBlock.Visibility = Visibility.Collapsed;//设置控件隐藏
// }
// else//选中当前菜品
// {
// _proNumBlock.Visibility = Visibility.Visible;//设置控件可见
// }
// }
// }
//}));
//Application.Current.Dispatcher.BeginInvoke(new Action(() =>
//{
// //5、清空菜品面板中选择的菜品
// ListBoxItem a1 = new ListBoxItem();
// var a2 = dishListBox.ItemContainerGenerator;
// for (int i = 0; i < dishListBox.Items.Count; i++)
// {
// if (a2.ContainerFromIndex(i) is ListBoxItem)
// {
// a1 = a2.ContainerFromIndex(i) as ListBoxItem;
// //寻找指定的控件，即ProNumBlock控件
// ContentPresenter myContentPresenter2 = FindChildControlUtil.FindVisualChild<ContentPresenter>(a1);
// if (myContentPresenter2 == null)
// {
// return;
// }
// string a1pmGuid = (a1.Content as PointMenuInfo).pmGuid;
// //遍历新增的菜品订单，判断某个菜品的主键是否等于菜品列表中某个菜品的主键
// PointMenuInfo item = OrderInfoTable.Find(x => x.pmGuid.Equals(a1pmGuid));
// //如果相等，则寻找该listboxitem
// if (item != null)
// {
// break;
// }
// }
// }
// var c1 = selectedItem[0];
// PointMenuInfo c2=(PointMenuInfo)c1.Tag;
// c1.Content = c2;
// var c3 = c1.ContentTemplate;
// //寻找指定的控件，即ProNumBlock控件
// ContentPresenter myContentPresenter = FindChildControlUtil.FindVisualChild<ContentPresenter>(a1);
// if (myContentPresenter == null)
// {
// return;
// }
// DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
// StackPanel _proNumBlock = (StackPanel)myDataTemplate.FindName("ProNumBlock", myContentPresenter);
// if (_proNumBlock.IsVisible)//取消选中菜品
// {
// _proNumBlock.Visibility = Visibility.Collapsed;//设置控件隐藏
// }
// else//选中当前菜品
// {
// _proNumBlock.Visibility = Visibility.Visible;//设置控件可见
// }
//}));
}
});
}
}
/// <summary>
/// 菜品名称点击命令(listbox)
/// </summary>
public ICommand SelectDishCommand
{
get
{
return new RelayCommand(o =>
{
if (o is ListBox)
{
var mylistbox = (ListBox)o;
var myindex = mylistbox.SelectedIndex;//获取所选项的索引号
if (myindex == -1)
{
return;
}
dishListBox = (ListBox)o;
ListBoxItem a1 = new ListBoxItem();
var myitem = DishNameItem;
if (DishNameItem.msScalar == 0)
{
Notice.Show("当前菜品库存不足，请选择其他菜品！", "提示", 3, MessageBoxIcon.Error);
return;
}
var a2 = mylistbox.ItemContainerGenerator;
//遍历listbox所有的项集合
for (int i = 0; i < mylistbox.Items.Count; i++)
{
//如果当前项是一个listboxitem
if (a2.ContainerFromIndex(i) is ListBoxItem)
{
a1 = (ListBoxItem)a2.ContainerFromIndex(i);
//并且该项的内容等于当前选择菜品对象则中断循环
if (a1.Content.Equals(myitem))
{
a1.Tag = (PointMenuInfo)a1.Content;
selectedItem.Add(a1);
break;
}
}
}
//寻找指定的控件，即ProNumBlock控件
ContentPresenter myContentPresenter = FindChildControlUtil.FindVisualChild<ContentPresenter>(a1);
DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
StackPanel _proNumBlock = (StackPanel)myDataTemplate.FindName("ProNumBlock", myContentPresenter);
AddOrderInfoList.Clear();
if (_proNumBlock.IsVisible)//取消选中菜品
{
_proNumBlock.Visibility = Visibility.Collapsed;//设置控件隐藏
//遍历所有订单信息，如果某个订单等于当前选择菜品则从集合中移除
for (int i = OrderInfoTable.Count - 1; i >= 0; i--)
{
var _proItem = (PointMenuInfo)OrderInfoTable[i];
if (_proItem.pmGuid == DishNameItem.pmGuid)
{
OrderInfoTable.Remove(OrderInfoTable[i]);//从集合中移除
}
}
}
else//选中当前菜品
{
_proNumBlock.Visibility = Visibility.Visible;//设置控件为可见
PointMenuInfo buyProObj = new PointMenuInfo
{
pmGuid = DishNameItem.pmGuid,
msName = DishNameItem.msName,
msPrice = DishNameItem.msPrice,
msScalar = DishNameItem.msScalar,
buyNum = 1
};
OrderInfoTable.Add(buyProObj);//添加到集合中
}
ObservableCollection<PointMenuInfo> objOrderList = new ObservableCollection<PointMenuInfo>();
//循环所有订单并计算总费用和总数量
CostMoney = 0;
int costCount = 0;
foreach (PointMenuInfo itemPro in OrderInfoTable)
{
CostMoney = CostMoney + itemPro.msPrice * itemPro.buyNum;
costCount = costCount + itemPro.buyNum;
objOrderList.Add(itemPro);
}
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = CostMoney.ToString("c0", cn);
AddOrderInfoList = objOrderList;
TxtCostCountPro = costCount.ToString();
//这里是为了处理SelectionChanged事件，因为SelectionChanged事件在同一个item中只会执行一次，当再次点击时，必须改变listbox的索引号
//所以这里必须人为的设置当前选中项为-1，即不选中任何一个listboxitem，当再次点击同一个item时，SelectionChanged事件才会生效
//SelectionChanged事件是指当选择项发生更改时触发的事件，当selectindex没有变化时，该事件自然就不会发生，因此同一个选项两次点击时，只有第一次会发生
//SelectionChanged事件，同一对象在第2次点击时不会发生SelectionChanged事件，所以人为在这设置mylistbox.SelectedIndex = -1;
mylistbox.SelectedIndex = -1;
var my = selectedItem;
}
});
}
}
/// <summary>
/// 【开始点餐】或【继续点餐】命令
/// </summary>
public ICommand TableContinueCostCommand
{
get
{
return new RelayCommand(o =>
{
DishTypeList = getDishTypeList();//菜品类型
DishTableList = getDishTableList("");//菜品列表
//修改面板文字
TxtTabControlTitle = "菜品类型";
TxtTabControlName = "菜品面板";
//菜品控件可见
DishTypeTabPro = Visibility.Visible;//菜品类型可见
DishTypeListPro = Visibility.Visible;//菜品列表可见
//餐桌控件隐藏
DiningTypeTabPro = Visibility.Collapsed;//餐桌类型隐藏
DiningTableListPro = Visibility.Collapsed;//餐台列表隐藏
TabConsumeHeadPro = Visibility.Visible;//已开桌消费项目标题栏可见
TableConsumeList = GetDeskConsumeDetail(TableOrderNoPro);//获取餐台消费详情
OpenOrderInfoPro = Visibility.Visible;//空桌准备开单或继续点餐时新增菜品的表格可见
CostSumInfoPro = Visibility.Visible;//消费汇总
CheckOutPro = Visibility.Collapsed;//结账或继续点餐按钮隐藏
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = 0.ToString("c0", cn);
TxtCostCountPro = "0";
TableConsumeListMarginPro = new Thickness(0, -25, 0, 0);
TabConsumeHeadMarginPro = new Thickness(0, -85, 0, 0);
TableConsumeListHeightPro = "290";
});
}
}
/// <summary>
/// 数字按键点击
/// </summary>
public ICommand DinerPersonNumberCommand
{
get
{
return new RelayCommand(o =>
{
if (o is Button)
{
Button mybtn = o as Button;
var curNumValue = mybtn.Content.ToString();
if (curNumValue.Equals("."))
{
if (!string.IsNullOrEmpty(DinersPro))
{
if (DinersPro.IndexOf(".") < 0) DinersPro = DinersPro + curNumValue;
}
else
{
Notice.Show("当前取值不合法，请重新取值！", "提示", 3, MessageBoxIcon.Error);
}
}
else
{
DinersPro = DinersPro + curNumValue;
}
NumOrderPro = DinersPro;
}
});
}
}
/// <summary>
/// 数字按键删除
/// </summary>
public ICommand DinerPersonDeleteCommand
{
get
{
return new RelayCommand(o =>
{
if (o is Button)
{
Button mybtn = o as Button;
int length = DinersPro.Length;
if (length > 0)
{
string ob = DinersPro.Remove(length - 1, 1);
DinersPro = ob;
}
}
});
}
}
/// <summary>
/// 【立即开台】命令
/// </summary>
public ICommand TableStartOpenCommand
{
get
{
return new RelayCommand(o =>
{
if (string.IsNullOrEmpty(DinersPro))
{
Notice.Show("请输入消费人数！", "提示", 3, MessageBoxIcon.Info);
return;
}
var table = DiningTableItem;
var _tableOrderNo = string.Format("{0:yyyyMMddHHmmssffff}", DateTime.Now);
DiningTable upTabObj = new DiningTable();
upTabObj.rbGuid = table.tbId;
upTabObj.rName = table.tbName;
upTabObj.rtId = table.rtId;
upTabObj.rtState = "占用";
upTabObj.obId = _tableOrderNo;
upTabObj.rtNumber = int.Parse(DinersPro);
upTabObj.rtRemark = TableTxtRemarkPro;
var _upRes = tablebll.UpStateById(upTabObj).Result;
if (_upRes.statusCode == (int)ApiEnum.Status)
{
TableOrderNoPro = _tableOrderNo;
//开台成功后，判断是否勾选了“开单后立即新增消费项目”复选框
var _isCheckedCostOrder = ChkIsOrderDetailPro;
if (_isCheckedCostOrder)
{
TableConsumeList = GetDeskConsumeDetail(TableOrderNoPro);//根据订单号获取单个餐台的消费详情
DiningTypeTabPro = Visibility.Collapsed; //餐桌类型隐藏
DiningTableListPro = Visibility.Collapsed;//餐台列表隐藏
OpenTableInfoPro = Visibility.Collapsed;
OpenOrderInfoPro = Visibility.Visible;//空桌准备开单或继续点餐时新增菜品的表格可见
DishTypeTabPro = Visibility.Visible;//菜品类型可见
DishTypeListPro = Visibility.Visible;//菜品列表可见
//修改面板文字
TxtTabControlTitle = "菜品类型";
TxtTabControlName = "菜品面板";
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = CostMoney.ToString("c0", cn);
TxtCostCountPro = TableConsumeList.Count.ToString();
DishTypeList = getDishTypeList();//菜品类型
DishTableList = getDishTableList("");//菜品列表
}
else
{
DiningTypeList = getDiningTypeList(); //餐桌类型
DiningTableList = getDiningTableList(); //餐台列表
}
Notice.Show("开台成功！", "提示", 3, MessageBoxIcon.Success);
}
});
}
}
/// <summary>
/// 【开单】命令
/// </summary>
public ICommand TableStartOrderCommand
{
get
{
return new RelayCommand(o =>
{
if (OrderInfoTable.Count == 0)
{
Notice.Show("请选择消费菜品！", "提示", 3, MessageBoxIcon.Warning);
return;
}
//0、0获取当前餐桌信息
var tt = TableNamePro;
DiningTable _tabobj = tablebll.GetModelByCond(x => x.rName == TableNamePro).Result.data;
if (_tabobj == null)
{
Notice.Show("开单失败！", "提示", 3, MessageBoxIcon.Warning);
return;
}
//1、1生成帐单记录
List<BillConsume> billRecord = billConsumebll.CreateConsumeRecord(OrderInfoTable, TableOrderNoPro);
//1、2添加帐单记录
var _isAddOrder = billConsumebll.AddBillList(billRecord).Result;
if (_isAddOrder.statusCode != (int)ApiEnum.Status)
{
Notice.Show("开单失败！", "提示", 3, MessageBoxIcon.Warning);
Logger.Default.ProcessError(_isAddOrder.statusCode, "保存消费项目详情出现异常");
return;
}
//2、1生成库存记录
List<PointMenu> proPointMenuList = new List<PointMenu>();
foreach (PointMenuInfo itemPro in OrderInfoTable)
{
var curStock = itemPro.msScalar - itemPro.buyNum;//库存量-购买量
var _proObj = new PointMenuInfo
{
pmGuid = itemPro.pmGuid,
msScalar = curStock >= 0 ? curStock : 0
};
proPointMenuList.Add(_proObj);
}
//2、2更新菜品的库存量
var _upStock = menubll.UpPointMenuStock(proPointMenuList).Result;
if (_upStock.statusCode != (int)ApiEnum.Status)
{
Logger.Default.ProcessError(_upStock.statusCode, "更新商品库存出现异常");
return;
}
//3、1生成订单历史记录
double amountCost = 0;
//汇总消费总金额
foreach (var itemCost in billRecord)
{
amountCost += itemCost.msMoney * itemCost.msAmount;
}
//创建历史订单对象
var _openOrder = new BillHistory
{
obGuid = Guid.NewGuid().ToString(),
obId = TableOrderNoPro,
tName = TableNamePro,
obDate = DateTime.Now,
obNumber = _tabobj.rtNumber,
mId = "",//未涉及会员业务，暂置为空
lastUpDate = DateTime.Now,
opConsumeMoney = amountCost,
opDiscountMoney = 0,
opClientMoney = 0
};
//3、2保存消费订单历史
var _openOrderRes = billHistorybll.AddbillHistory(_openOrder).Result;
if (_openOrderRes.statusCode != (int)ApiEnum.Status)
{
Notice.Show("保存消费订单失败！", "提示", 3, MessageBoxIcon.Error);
Logger.Default.ProcessError(_openOrderRes.statusCode, "保存消费订单出现异常");
return;
}
//4、1 清空餐台界面信息
TxtCostMonePro = "";//清空金额
TxtCostCountPro = "";//清空数量
AddOrderInfoList.Clear();//清空新增的菜品列表
//清空点单金额和点单数量
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = 0.ToString("c0", cn);
TxtCostCountPro = 0.ToString();
//4、2更新餐台数据信息及状态
_tabobj.rtDate = DateTime.Now;//开单时间
var _upres = tablebll.UpStateById(_tabobj).Result;
if (_upres.statusCode != (int)ApiEnum.Status)
{
Notice.Show("开单失败！", "提示", 3, MessageBoxIcon.Error);
Logger.Default.ProcessError(_openOrderRes.statusCode, "更新餐桌出现异常");
return;
}
TabConsumeHeadPro = Visibility.Visible;//已开桌消费项目标题栏可见
TabConsumeListPro = Visibility.Visible;//已开单餐台消费列表可见
//修改消费标题及Listbox列表的margin设置
TableConsumeListMarginPro = new Thickness(0, -25, 0, 0);
TabConsumeHeadMarginPro = new Thickness(0, -85, 0, 0);
//修改消费标题及Listbox列表的高度设置
TableConsumeListHeightPro = "290";
TableConsumeList = GetDeskConsumeDetail(TableOrderNoPro);//重新获取餐台消费详情
CostSumInfoPro = Visibility.Visible;//消费汇总可见
CheckOutPro = Visibility.Collapsed;//结账或继续点餐按钮隐藏
CheckOutPro2 = Visibility.Collapsed;//消费时长及消费人数的stackpanel控件隐藏
//5、清空菜品面板选中的菜品
ListBoxItem a1 = new ListBoxItem();
var a2 = dishListBox.ItemContainerGenerator;
for (int i = 0; i < dishListBox.Items.Count; i++)
{
if (a2.ContainerFromIndex(i) is ListBoxItem)
{
a1 = a2.ContainerFromIndex(i) as ListBoxItem;
string a1pmGuid = (a1.Content as PointMenuInfo).pmGuid;
//遍历新增的菜品订单，判断某个菜品的主键是否等于菜品列表中某个菜品的主键
PointMenuInfo item = OrderInfoTable.Find(x => x.pmGuid.Equals(a1pmGuid));
//如果相等，则寻找该listboxitem
if (item != null)
{
//寻找指定的控件，即ProNumBlock控件
ContentPresenter myContentPresenter = FindChildControlUtil.FindVisualChild<ContentPresenter>(a1);
DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
StackPanel _proNumBlock = (StackPanel)myDataTemplate.FindName("ProNumBlock", myContentPresenter);
if (_proNumBlock.IsVisible)//取消选中菜品
{
_proNumBlock.Visibility = Visibility.Collapsed;//设置控件隐藏
}
else//选中当前菜品
{
_proNumBlock.Visibility = Visibility.Visible;//设置控件可见
}
}
}
}
OrderInfoTable.Clear();//清空已选菜品帐单
Notice.Show("开单成功！", "提示", 3, MessageBoxIcon.Success);
DishTableList = getDishTableList(globalGuid);//刷新菜品列表
});
}
}
/// <summary>
/// 【关闭】命令
/// </summary>
public ICommand TableCancelOrderCommand
{
get
{
return new RelayCommand(o =>
{
OpenOrderInfoPro = Visibility.Collapsed;//空闲餐桌需要准备"开单"的详情隐藏
TabConsumeHeadPro = Visibility.Collapsed;//已经开单餐桌的消费标题详情隐藏
TabConsumeListPro = Visibility.Collapsed;//已经开单餐桌的消费清单详情隐藏
CostSumInfoPro = Visibility.Collapsed;//已经开单餐桌的消费清单汇总隐藏
DishTypeListPro = Visibility.Collapsed;//菜品列表隐藏
DishTypeTabPro = Visibility.Collapsed;//菜品类型隐藏
DiningTypeTabPro = Visibility.Visible;//餐桌类型可见
DiningTableListPro = Visibility.Visible;//餐台列表可见
OpenTableInfoPro = Visibility.Visible;//空闲餐台详情可见
DiningTypeList = getDiningTypeList(); //餐桌类型
DiningTableList = getDiningTableList(); //餐台列表
TxtTabControlTitle = "餐桌类型";
TxtTabControlName = "餐台面板";
DinersPro = "";//就餐人数
TableTxtRemarkPro = "";//备注信息
ChkIsOrderDetailPro = false;//是否开单复选框
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = CostMoney.ToString("c0", cn);
TxtCostCountPro = "";
AddOrderInfoList.Clear();//清空开单信息
OrderInfoTable.Clear();//清空开台信息
});
}
}
/// <summary>
/// 菜品数量增加命令
/// </summary>
public ICommand BuyNumPlusCmd
{
get
{
return new RelayCommand(o =>
{
string menuguid = o.ToString();
PointMenuInfo record = OrderInfoTable.First(x => x.pmGuid.Equals(menuguid));
if (record.buyNum > 0)
{
if (record.buyNum < record.msScalar)//购买数量必须小于库存时才能增加
{
record.buyNum++;
ObservableCollection<PointMenuInfo> objOrderList = new ObservableCollection<PointMenuInfo>();
//循环所有订单位计算总费用
CostMoney = 0;
int costCount = 0;
foreach (PointMenuInfo itemPro in OrderInfoTable)
{
CostMoney = CostMoney + itemPro.msPrice * itemPro.buyNum;
costCount = costCount + itemPro.buyNum;
objOrderList.Add(itemPro);
}
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = CostMoney.ToString("c0", cn);
AddOrderInfoList = objOrderList;
TxtCostCountPro = costCount.ToString();
}
else
{
var _msgRes = MessageBoxX.Show("对不起，消费数量不能超过库存数量", "提示", Application.Current.MainWindow, MessageBoxButton.OK, new MessageBoxXConfigurations()
{
MessageBoxIcon = MessageBoxIcon.Warning,
ButtonBrush = "#F1C825".ToColor().ToBrush(),
});
}
}
});
}
}
/// <summary>
/// 菜品数量减少命令
/// </summary>
public ICommand BuyNumSubtractCmd
{
get
{
return new RelayCommand(o =>
{
string menuguid = o.ToString();
PointMenuInfo record = OrderInfoTable.First(x => x.pmGuid.Equals(menuguid));
if (record.buyNum > 1)
{
record.buyNum--;
ObservableCollection<PointMenuInfo> objOrderList = new ObservableCollection<PointMenuInfo>();
//循环所有订单位计算总费用
CostMoney = 0;
int costCount = 0;
foreach (PointMenuInfo itemPro in OrderInfoTable)
{
CostMoney = CostMoney + itemPro.msPrice * itemPro.buyNum;
costCount = costCount + itemPro.buyNum;
objOrderList.Add(itemPro);
}
CultureInfo cn = new CultureInfo("zh-CN");
TxtCostMonePro = CostMoney.ToString("c0", cn);
AddOrderInfoList = objOrderList;
TxtCostCountPro = costCount.ToString();
}
});
}
}
/// <summary>
/// 结账命令
/// </summary>
public ICommand SettlementCostCommand
{
get
{
return new RelayCommand(o =>
{
//1、获取订单数据
var res = billHistorybll.GetBillHistoryList(x => x.obId == TableOrderNoPro).Result;
if (res.statusCode != (int)ApiEnum.Status)
{
Notice.Show("操作失败，请联系您的管理员！", "提示", 3, MessageBoxIcon.Warning);
return;
}
List<BillHistory> historyorderObj = res.data.OrderBy(x => x.opConsumeMoney).ToList();
if (historyorderObj == null)
{
Notice.Show("操作失败，请联系您的管理员！", "提示", 3, MessageBoxIcon.Warning);
return;
}
////2、更新结账金额
foreach (BillHistory h in historyorderObj)
{
h.opClientMoney = h.opConsumeMoney;
h.lastUpDate = DateTime.Now;
var upRes = billHistorybll.UpPayMoneyAttr(h).Result;
if (upRes.statusCode != (int)ApiEnum.Status)
{
Notice.Show("结账失败，请联系您的管理员！", "提示", 3, MessageBoxIcon.Warning);
Logger.Default.ProcessError(upRes.statusCode, "更新结账金额出现异常,订单号【" + TableOrderNoPro + "】");
return;
}
}
//3、更新餐桌状态
var tabObjRes = tablebll.GetModelByCond(x => x.rName == TableNamePro).Result.data;
tabObjRes.rtState = "空闲";
tabObjRes.rtDate = null;
tabObjRes.rtNumber = 0;
tabObjRes.rtRemark = string.Empty;
tabObjRes.obId = string.Empty;
var upTabRes = tablebll.UpStateById(tabObjRes).Result;
if (upTabRes.statusCode != (int)ApiEnum.Status)
{
Notice.Show("结账失败，请联系您的管理员！", "提示", 3, MessageBoxIcon.Warning);
Logger.Default.ProcessError(upTabRes.statusCode, "更新餐桌状态出现异常,餐桌号【" + TableNamePro + "】");
}
else
{
RefreshPage();//刷新界面
Notice.Show("结账成功！", "提示", 3, MessageBoxIcon.Success);
}
});
}
}
#endregion
}
}
4、运行测试
呈现所有菜品，点击不同类型菜品，显示该类型下的菜
原创不易，打字截图不易，走过路过，不要错过，欢迎点赞，收藏，转载，复制，抄袭，留言，动动你的金手指，早日实现财务自由！
