zhipuzi_pos_windows/zhipuzi_pos_windows/zhipuzi/CZhengcanOrder.cpp

#include "../pch/pch.h"
#include "CZhengcanOrder.h"
#include "../tool/CSqlite3.h"

void CZhengcanOrder::RefreshDiandanInfo()
{
	m_order_history_array.clear();
	m_items.clear();

	m_total_price_show = "";
	m_memo = "";

	shopname = "";
	show_trade_no = "";
	balance = "";
	member_number = "";
	m_renshu = "";
	shoukuan_type = "";

	int order_from = 1;

	init_time = "";
	m_shangpinquan_youhui = "";
	m_cika_youhui = "";
	m_total_member_youhui = "";
	m_zhekou_youhui = "";
	m_member_zhekou_youhui = "";
	m_quanyika_youhui = "";
	m_manjian_youhui = "";
	m_youhuiquan_youhui = "";
	m_rengong_youhui = "";
	m_moling_youhui = "";
	m_jiajia = "";
	m_shishou_value = "";
	m_zhaoling_value = "";
	m_zhekou_value = "";
	m_dabao_money = "";
	m_total_price = "";

	m_items_print.clear();

	m_order_id = "";
	is_refund = "";
	refund_time = "";
	is_guazhang = "";
	guazhang = "";
}

int CZhengcanOrder::getItemNum()
{
	return m_items.size();
}

bool CZhengcanOrder::GetHistoryItemById(std::string item_id, CZhengcanOrderItem& item)
{
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->item_id == item_id)
			{
				item = *it1;

				return true;
			}
		}
	}

	return false;
}

double CZhengcanOrder::getTotalPrice()
{
	double total_price_show = 0;

	//先计算当前已点的商品
	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		total_price_show += std::stod((*it).show_price);
	}

	//再计算已下单商品
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->is_tuicai == "1")
			{
				//退菜的不算
				continue;
			}

			total_price_show += std::stod((*it1).show_price);
		}
	}

	return total_price_show;
}

CZhengcanOrderItem CZhengcanOrder::getDiandanOrderItem(int index)
{
	return m_items[index];
}

//这个函数的逻辑是选择一个新商品的时候，与已有商品进行对比，看看是加一个新的商品，还是对已有商品增加数量
//返回值是表示新加的item，在第几个元素，方便刷新显示
int CZhengcanOrder::AddItem(CZhengcanOrderItem newitem, bool& is_add_new)
{
	int index = 0;
	bool is_found = false;

	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		CZhengcanOrderItem curItem = *it;

		if (curItem == newitem)
		{
			is_found = true;
			break;
		}

		index++;
	}

	//如果找到了，更新数量
	if (is_found)
	{
		std::string old_num = m_items[index].num;

		double d_old_num = std::stod(old_num);
		double d_new_num = d_old_num + std::stod(newitem.num);

		//如果新的数量是一个整数，那么展示的时候就把小数去掉
		if (d_new_num - (int)d_new_num < 0.0001)
		{
			m_items[index].num = std::to_string((int)d_new_num);
		}
		else
		{
			m_items[index].num = CLewaimaiString::DoubleToString(d_new_num, 3);
		}

		m_items[index].UpdateShowPrice();

		is_add_new = false;
	}
	else
	{
		//如果没找到，直接加一个新的item
		m_items.push_back(newitem);

		m_items[index].UpdateShowPrice();

		is_add_new = true;
	}

	return index;
}

void CZhengcanOrder::UpdateItemGuige(int index, std::vector<FoodNatureSelectValue>& natureSelectedArray)
{
	m_items[index].natureSelectedArray = natureSelectedArray;

	this->UpdateGuigePrice(index);
}

//给某一项添加一个数量
void CZhengcanOrder::AddNum(int index)
{
	std::string old_num = m_items[index].num;

	double d_old_num = std::stod(old_num);
	double d_new_num = d_old_num + 1;

	//如果新的数量是一个整数，那么展示的时候就把小数去掉
	if (d_new_num - (int)d_new_num < 0.0001)
	{
		m_items[index].num = std::to_string((int)d_new_num);
	}
	else
	{
		m_items[index].num = CLewaimaiString::DoubleToString(d_new_num, 3);
	}

	m_items[index].UpdateShowPrice();
}

//给某一项减少一个数量，返回值为true表示商品本删掉了，也就是为0份；如果为false表示没被删掉
bool CZhengcanOrder::DelNum(int index)
{
	std::string old_num = m_items[index].num;

	double d_old_num = std::stod(old_num);
	double d_new_num = d_old_num - 1;

	if (d_new_num < 0.0001)
	{
		//已经减为0了，那么就删掉这个item
		m_items.erase(m_items.begin() + index);

		return true;
	}
	else
	{
		//如果新的数量是一个整数，那么展示的时候就把小数去掉
		if (d_new_num - (int)d_new_num < 0.0001)
		{
			m_items[index].num = std::to_string((int)d_new_num);
		}
		else
		{
			m_items[index].num = CLewaimaiString::DoubleToString(d_new_num, 3);
		}

		m_items[index].UpdateShowPrice();
	}

	return false;
}

//删除某一项
void CZhengcanOrder::Remove(int index)
{
	//已经减为0了，那么就删掉这个item
	m_items.erase(m_items.begin() + index);
}

//更新了某项的规格，那么重新刷新显示和价格
void CZhengcanOrder::UpdateGuigePrice(int index)
{
	m_items[index].UpdateShowPrice();
}

void CZhengcanOrder::SetDabao(int index)
{
	m_items[index].SetDabao();
}

//清空商品
void CZhengcanOrder::Clear()
{
	m_items.clear();
}

void CZhengcanOrder::SetMemo(std::string memo)
{
	m_memo = memo;
}

std::string CZhengcanOrder::GetMemo()
{
	return m_memo;
}

bool CZhengcanOrder::UseShangpinquan(std::string shangpinquan_food_id, double& youhui_value)
{
	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		CZhengcanOrderItem curItem = *it;

		if (curItem.m_is_taocan == false && curItem.food_id == shangpinquan_food_id)
		{
			//找到了可以使用的商品
			if (atof(curItem.num.c_str()) > 0.99999)
			{
				//如果当前份数大于1，那么抵扣价格就是商品单价
				youhui_value = atof(curItem.price.c_str());
			}
			else
			{
				//如果当前份数不足1份，那么就抵扣价格就是单价乘以数量
				youhui_value = atof(curItem.price.c_str()) * atof(curItem.num.c_str());
			}

			return true;
		}
	}

	//继续在已下单的订单里面找
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->is_tuicai == "1")
			{
				//退菜的不算
				continue;
			}

			CZhengcanOrderItem curItem = *it1;

			if (curItem.m_is_taocan == false && curItem.food_id == shangpinquan_food_id)
			{
				//找到了可以使用的商品
				if (atof(curItem.num.c_str()) > 0.99999)
				{
					//如果当前份数大于1，那么抵扣价格就是商品单价
					youhui_value = atof(curItem.price.c_str());
				}
				else
				{
					//如果当前份数不足1份，那么就抵扣价格就是单价乘以数量
					youhui_value = atof(curItem.price.c_str()) * atof(curItem.num.c_str());
				}

				return true;
			}
		}
	}

	return false;
}

bool CZhengcanOrder::UseCikaDikou(std::string cika_food_id, double& youhui_value, bool is_shangpinquan_dikou)
{
	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		CZhengcanOrderItem curItem = *it;

		if (curItem.m_is_taocan == false && curItem.food_id == cika_food_id)
		{
			//找到了可以使用的商品
			if (is_shangpinquan_dikou)
			{
				if (atof(curItem.num.c_str()) > 1.99999)
				{
					//如果当前份数大于2，那么抵扣价格就是商品单价
					youhui_value = atof(curItem.price.c_str());
				}
				else if (atof(curItem.num.c_str()) > 0.99999)
				{
					//如果当前份数不足2份，但是大于1份，那么就抵扣价格就是单价乘以数量
					youhui_value = atof(curItem.price.c_str()) * (atof(curItem.num.c_str()) - 1);
				}
				else
				{
					//如果当前份数不足1份，那么已经被商品券抵扣了，次卡不再抵扣
					youhui_value = 0;

					return false;
				}
			}
			else
			{
				if (atof(curItem.num.c_str()) > 0.99999)
				{
					//如果当前份数大于1，那么抵扣价格就是商品单价
					youhui_value = atof(curItem.price.c_str());
				}
				else
				{
					//如果当前份数不足1份，那么就抵扣价格就是单价乘以数量
					youhui_value = atof(curItem.price.c_str()) * atof(curItem.num.c_str());
				}
			}

			return true;
		}
	}

	//继续在已下单的订单里面找
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->is_tuicai == "1")
			{
				//退菜的不算
				continue;
			}

			CZhengcanOrderItem curItem = *it1;

			if (curItem.m_is_taocan == false && curItem.food_id == cika_food_id)
			{
				//找到了可以使用的商品
				if (is_shangpinquan_dikou)
				{
					if (atof(curItem.num.c_str()) > 1.99999)
					{
						//如果当前份数大于2，那么抵扣价格就是商品单价
						youhui_value = atof(curItem.price.c_str());
					}
					else if (atof(curItem.num.c_str()) > 0.99999)
					{
						//如果当前份数不足2份，但是大于1份，那么就抵扣价格就是单价乘以数量
						youhui_value = atof(curItem.price.c_str()) * (atof(curItem.num.c_str()) - 1);
					}
					else
					{
						//如果当前份数不足1份，那么已经被商品券抵扣了，次卡不再抵扣
						youhui_value = 0;

						return false;
					}
				}
				else
				{
					if (atof(curItem.num.c_str()) > 0.99999)
					{
						//如果当前份数大于1，那么抵扣价格就是商品单价
						youhui_value = atof(curItem.price.c_str());
					}
					else
					{
						//如果当前份数不足1份，那么就抵扣价格就是单价乘以数量
						youhui_value = atof(curItem.price.c_str()) * atof(curItem.num.c_str());
					}
				}

				return true;
			}
		}
	}

	return false;
}

double CZhengcanOrder::getTotalMemberYouhui(std::string member_level)
{
	double total_youhui = 0;

	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		CZhengcanOrderItem curItem = *it;

		double item_youhui = curItem.getMemberYouhui(member_level);

		total_youhui += item_youhui;
	}

	//继续在已下单的订单里面找
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->is_tuicai == "1")
			{
				//退菜的不算
				continue;
			}

			CZhengcanOrderItem curItem = *it1;

			double item_youhui = curItem.getMemberYouhui(member_level);

			total_youhui += item_youhui;
		}
	}

	return total_youhui;
}

//计算所有商品的总的打包费
double CZhengcanOrder::getDabaoMoney()
{
	double total_dabao = 0;

	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		CZhengcanOrderItem curItem = *it;

		double item_dabao = curItem.getDabaoMoney();

		total_dabao += item_dabao;
	}

	//继续在已下单的订单里面找
	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->is_tuicai == "1")
			{
				//退菜的不算
				continue;
			}

			CZhengcanOrderItem curItem = *it1;

			double item_dabao = curItem.getDabaoMoney();

			total_dabao += item_dabao;
		}
	}

	return total_dabao;
}

//获取点单相关的参数（仅用于非套餐）
std::string CZhengcanOrder::getDiandanFoodlistParam()
{
	std::vector<std::map<string, string>> params;

	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		if (it->m_is_taocan)
		{
			continue;
		}

		std::map<string, string> itemParam = it->getDiandanParam();	

		params.push_back(itemParam);
	}

	std::string s_params = CLewaimaiJson::ParamArrayToJsonstring(params);

	return s_params;
}

//获取点单相关的套餐参数（仅用于套餐）
std::string CZhengcanOrder::getDiandanTaocanParam()
{
	rapidjson::Document doc;
	doc.SetArray();
	rapidjson::Document::AllocatorType &allocator = doc.GetAllocator(); //获取分配器

	for (std::vector<CZhengcanOrderItem>::iterator it = m_items.begin(); it != m_items.end(); it++)
	{
		if (it->m_is_taocan == false)
		{
			continue;
		}

		Value& data = it->getDiandanTaocanParam(allocator);
		doc.PushBack(data, allocator);
	}

	std::string paramString = CLewaimaiJson::JsonToString(doc);

	return paramString;
}

bool CZhengcanOrder::InitData(std::string order_id)
{
	std::map<string, string> params;
	params["order_id"] = order_id;

	std::string response;
	bool ret = CZhipuziHttpClient::GetInstance()->Request("/dinnercash/getorderdetail", params, response);
	if (!ret)
	{
		LOG_INFO("网络请求出错");
		return false;
	}

	rapidjson::Document document;
	document.Parse(response.c_str());

	if (document.HasParseError())
	{
		LOG_INFO("parse response error!");
		return false;
	}

	if (!document.HasMember("errcode") || !document.HasMember("errmsg") || !document.HasMember("data"))
	{
		LOG_INFO("json error!");
		return false;
	}

	rapidjson::Value& v_errcode = document["errcode"];
	int errcode = v_errcode.GetInt();
	if (errcode != 0)
	{
		LOG_INFO("response failed! message:" << document["errmsg"].GetString());
		return false;
	}

	//获得数据成功
	rapidjson::Value& data = document["data"];

	shopname = CShopinfo::GetInstance()->m_shop_name;

	m_order_id = data["id"].GetString();
	show_trade_no = data["show_trade_no"].GetString();
	m_renshu = data["person_num"].GetString();
	m_table_id = CLewaimaiJson::ToString(data["table_id"]);
	table_name = CLewaimaiJson::ToString(data["table_name"]);
	m_memo = CLewaimaiJson::ToString(data["note"]);

	m_dabao_money = data["dabao_price"].GetString();

	m_zhekou_value = data["discount"].GetString();
	m_rengong_youhui = data["coupon"].GetString();
	m_jiajia = data["price_plus"].GetString();
	m_moling_youhui = data["price_moling"].GetString();
	m_total_price = data["yingshou_price"].GetString();
	m_shishou_value = data["shishou_value"].GetString();
	m_zhaoling_value = data["zhaoling_value"].GetString();
	
	shoukuan_type = data["zhifu_type"].GetString();
	
	is_refund = data["is_refund"].GetString();
	refund_time = CLewaimaiJson::ToString(data["refund_time"]);
	is_guazhang = data["is_guazhang"].GetString();
	guazhang = data["guazhang"].GetString();
	m_youhuiquan_youhui = data["coupon_value"].GetString();
	m_total_member_youhui = data["member_delete"].GetString();
	m_manjian_youhui = data["promotion_value"].GetString();
	m_member_zhekou_youhui = data["member_discount_money"].GetString();
	m_zhekou_youhui = data["discount_delete"].GetString();
	m_cika_youhui = data["timescoupon_discount_money"].GetString();
	m_quanyika_youhui = data["eq_card_discount_money"].GetString();

	init_time = CLewaimaiJson::ToString(data["init_time"]);
	m_is_clear = CLewaimaiJson::ToString(data["is_clear"]);
	m_kaitai_time = CLewaimaiJson::ToString(data["kaitai_time"]);
	m_pay_time = CLewaimaiJson::ToString(data["pay_time"]);

	m_status = data["status"].GetString();

	shoukuan_type = data["zhifu_type"].GetString();

	std::string fromtype = data["from_type"].GetString();
	if (fromtype == "1")
	{
		order_from = 1;
	}
	else if (fromtype == "4")
	{
		order_from = 2;
	}
	else if (fromtype == "2" || fromtype == "3")
	{
		order_from = 3;
	}

	//开始保存订单详情
	rapidjson::Value& v_rows = data["item"];

	//这个是已经下单的次数，已经下单N次这里值就是N
	int nItemNum = v_rows.Size();

	for (rapidjson::SizeType j = 0; j < v_rows.Size(); ++j)
	{
		CZhengcanOrderHistoryXiadan newHistoryXiadan;
		newHistoryXiadan.xiadanNum = j;

		//这里每次循环，就是一次下单的商品信息
		rapidjson::Value& xiadanInfos = v_rows[j];

		//先处理非套餐
		rapidjson::Value& food_list = xiadanInfos["food_list"];
		for (rapidjson::SizeType i = 0; i < food_list.Size(); ++i)
		{
			rapidjson::Value& foodinfo = food_list[i];

			CZhengcanOrderItem newItem;
			newItem.m_is_history_item = true;

			newItem.item_id = CLewaimaiJson::ToString(foodinfo["id"]);
			newItem.food_id = CLewaimaiJson::ToString(foodinfo["food_id"]);
			newItem.food_name = CLewaimaiJson::ToString(foodinfo["food_name"]);
			newItem.type_id = CLewaimaiJson::ToString(foodinfo["type_id"]);
			newItem.price = CLewaimaiJson::ToString(foodinfo["single_price"]);
			newItem.num = CLewaimaiJson::ToString(foodinfo["quantity"]);

			if (CLewaimaiJson::ToString(foodinfo["is_dabao"]) == "1")
			{
				newItem.is_dabao = true;
			}
			else
			{
				newItem.is_dabao = false;
			}

			//目前服务器返回的dabao_money一直为0，是不对的，暂时不用这个，下面从数据库里读取
			//newItem.dabao_money = CLewaimaiJson::ToString(foodinfo["dabao_money"]);

			newItem.is_jiacai = CLewaimaiJson::ToString(foodinfo["is_jiacai"]);
			newItem.jiacai_no = CLewaimaiJson::ToString(foodinfo["jiacai_no"]);
			newItem.is_tuicai = CLewaimaiJson::ToString(foodinfo["is_tuicai"]);

			//从数据库里读这个商品的信息，获取会员价信息
			CFood foodinfo_bendi;
			CSqlite3 sqlite;
			bool ret = sqlite.GetFoodById(newItem.food_id, foodinfo_bendi);
			if (ret == true)
			{
				newItem.dabao_money = foodinfo_bendi.dabao_money;

				if (foodinfo_bendi.member_price_used == "1")
				{
					newItem.is_member_price_used = true;
				}
				else
				{
					newItem.is_member_price_used = false;
				}

				//处理会员价的json
				std::string member_price_json = foodinfo_bendi.member_price_json;

				rapidjson::Document document;
				document.Parse(member_price_json.c_str());

				rapidjson::Value& member_price = document;
				for (rapidjson::SizeType i = 0; i < member_price.Size(); ++i)
				{
					rapidjson::Value& member_price_info = member_price[i];

					MemberPrice newPirce;
					newPirce.id = CLewaimaiJson::ToString(member_price_info["id"]);
					newPirce.level = CLewaimaiJson::ToString(member_price_info["level"]);

					if (member_price_info["price"].IsString())
					{
						newPirce.price = member_price_info["price"].GetString();
					}
					else
					{
						newPirce.price = to_string(member_price_info["price"].GetDouble());
					}

					newItem.m_member_price.push_back(newPirce);
				}
			}
			else
			{
				//说明已下单的商品，已经被从本地删除了！
				newItem.is_member_price_used = false;

				newItem.dabao_money = "0";
			}

			newItem.UpdateShowPrice();

			newHistoryXiadan.m_items.push_back(newItem);
		}

		//再处理套餐
		rapidjson::Value& foodpackage_array = xiadanInfos["foodpackage_array"];
		for (rapidjson::SizeType i = 0; i < foodpackage_array.Size(); ++i)
		{
			rapidjson::Value& cur_foodpackage = foodpackage_array[i];

			CZhengcanOrderItem newItem;
			newItem.m_is_history_item = true;

			newItem.item_id = CLewaimaiJson::ToString(cur_foodpackage["id"]);
			newItem.num = cur_foodpackage["quantity"].GetString();
			newItem.price = cur_foodpackage["single_price"].GetString();
			newItem.foodpackage_id = cur_foodpackage["foodpackage_id"].GetString();
			newItem.is_tuicai = cur_foodpackage["is_tuicai"].GetString();

			if (CLewaimaiJson::ToString(cur_foodpackage["is_dabao"]) == "1")
			{
				newItem.is_dabao = true;
			}
			else
			{
				newItem.is_dabao = false;
			}

			newItem.is_jiacai = CLewaimaiJson::ToString(cur_foodpackage["is_jiacai"]);
			newItem.jiacai_no = CLewaimaiJson::ToString(cur_foodpackage["jiacai_no"]);
			newItem.is_tuicai = CLewaimaiJson::ToString(cur_foodpackage["is_tuicai"]);

			//从数据库读取套餐的打包费信息
			CFoodpackage foodpackageinfo;
			CSqlite3 sqlite;
			bool ret = sqlite.GetFoodpackageById(newItem.foodpackage_id, foodpackageinfo);
			if (ret == true)
			{
				newItem.dabao_money = foodpackageinfo.dabao_money;
			}
			else
			{
				//说明已下单的套餐，已经被从本地删除了！
				newItem.dabao_money = "0";
			}

			newItem.m_is_taocan = true;
			newItem.foodpackage_name = cur_foodpackage["food_name"].GetString();

			//接着保存套餐的item
			rapidjson::Value& food_item = cur_foodpackage["food_item"];
			for (rapidjson::SizeType m = 0; m < food_item.Size(); ++m)
			{
				rapidjson::Value& food_item_info = food_item[m];

				//开始保存套餐Item
				CZhengcanOrderItem taocanItem;

				taocanItem.m_is_history_item = true;

				taocanItem.item_id = CLewaimaiJson::ToString(food_item_info["id"]);
				taocanItem.food_id = CLewaimaiJson::ToString(food_item_info["food_id"]);
				taocanItem.food_name = CLewaimaiJson::ToString(food_item_info["food_name"]);
				taocanItem.type_id = CLewaimaiJson::ToString(food_item_info["type_id"]);
				taocanItem.price = CLewaimaiJson::ToString(food_item_info["single_price"]);
				taocanItem.num = CLewaimaiJson::ToString(food_item_info["quantity"]);

				if (CLewaimaiJson::ToString(food_item_info["is_dabao"]) == "1")
				{
					taocanItem.is_dabao = true;
				}
				else
				{
					taocanItem.is_dabao = false;
				}

				newItem.is_jiacai = CLewaimaiJson::ToString(food_item_info["is_jiacai"]);
				newItem.jiacai_no = CLewaimaiJson::ToString(food_item_info["jiacai_no"]);
				newItem.is_tuicai = CLewaimaiJson::ToString(food_item_info["is_tuicai"]);

				//目前服务器返回的dabao_money一直为0，是不对的，暂时不用这个，下面从数据库里读取
				//newItem.dabao_money = CLewaimaiJson::ToString(foodinfo["dabao_money"]);

				taocanItem.is_jiacai = CLewaimaiJson::ToString(food_item_info["is_jiacai"]);
				taocanItem.jiacai_no = CLewaimaiJson::ToString(food_item_info["jiacai_no"]);
				taocanItem.is_tuicai = CLewaimaiJson::ToString(food_item_info["is_tuicai"]);

				newItem.m_taocan_items.push_back(taocanItem);
			}

			newItem.UpdateShowPrice();

			newHistoryXiadan.m_items.push_back(newItem);
		}

		m_order_history_array.push_back(newHistoryXiadan);
	}

	return true;
}

bool CZhengcanOrder::Refund(std::string order_id)
{
	std::string url = "/dinnercash/refund";

	//请求外卖的未处理订单
	std::map<string, string> params;
	params["id"] = order_id;
	std::string response;

	CZhipuziHttpClient::GetInstance()->Request(url.c_str(), params, response);

	rapidjson::Document document;
	document.Parse(response.c_str());

	if (document.HasParseError())
	{
		LOG_INFO("parse response error!");
		return false;
	}

	if (!document.HasMember("errcode") || !document.HasMember("errmsg") || !document.HasMember("data"))
	{
		LOG_INFO("json error!");
		return false;
	}

	rapidjson::Value& v_errcode = document["errcode"];
	int errcode = v_errcode.GetInt();
	if (errcode != 0)
	{
		LOG_INFO("response failed! message:" << document["errmsg"].GetString());
		return false;
	}

	return true;
}

void CZhengcanOrder::UpdateItemPrint()
{
	//清空之前的打印记录
	m_items_print.clear();

	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			CZhengcanOrderItemPrint itemPrint;

			CZhengcanOrderItem tuicaiItem = *it1;

			if (tuicaiItem.is_tuicai == "1")
			{
				itemPrint.is_tuicai = true;
			}

			itemPrint.m_quantity = tuicaiItem.num;
			itemPrint.m_item_price = tuicaiItem.price;
			itemPrint.m_type_id = tuicaiItem.type_id;

			if (tuicaiItem.m_is_taocan == true)
			{
				itemPrint.is_taocan = true;

				itemPrint.m_food_name = tuicaiItem.foodpackage_name; //不带属性商品
			}
			else
			{
				itemPrint.m_food_name = tuicaiItem.food_name; //带属性值
			}

			m_items_print.push_back(itemPrint);

			if (tuicaiItem.m_is_taocan == true)
			{
				//开始保存套餐里面的商品详情，主要用于厨房打印

				//接下来要把这个套餐的详情也保存下来
				for (std::vector<CZhengcanOrderItem>::iterator it = tuicaiItem.m_taocan_items.begin(); it != tuicaiItem.m_taocan_items.end(); it++)
				{
					std::string food_id = it->food_id;

					//要根据商品ID找出商品的名字
					CFood foodinfo;
					CSqlite3 sqlite;
					bool is_found = sqlite.GetFoodById(food_id, foodinfo);
					if (!is_found)
					{
						continue;
					}

					CZhengcanOrderItemPrint foodpackageitemPrint;

					foodpackageitemPrint.m_food_name = foodinfo.name;
					foodpackageitemPrint.m_quantity = tuicaiItem.num;
					foodpackageitemPrint.m_item_price = foodinfo.price;
					foodpackageitemPrint.m_type_id = foodinfo.type_id;

					foodpackageitemPrint.is_taocan = false;
					foodpackageitemPrint.is_taocan_item = true;

					m_items_print.push_back(foodpackageitemPrint);
				}
			}
		}
	}
}

void CZhengcanOrder::UpdateItemPrintForJiacai(std::string jiacai_no)
{
	//清空之前的打印记录
	m_items_print.clear();

	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (jiacai_no != "-1")
			{
				if (it1->jiacai_no != jiacai_no)
				{
					//如果jiacai_no不想等，就直接忽略
					continue;
				}
			}

			CZhengcanOrderItemPrint itemPrint;

			CZhengcanOrderItem tuicaiItem = *it1;

			itemPrint.m_quantity = tuicaiItem.num;
			itemPrint.m_item_price = tuicaiItem.price;
			itemPrint.m_type_id = tuicaiItem.type_id;

			if (tuicaiItem.m_is_taocan == true)
			{
				itemPrint.is_taocan = true;

				itemPrint.m_food_name = tuicaiItem.foodpackage_name; //不带属性商品
			}
			else
			{
				itemPrint.m_food_name = tuicaiItem.food_name; //带属性值
			}

			m_items_print.push_back(itemPrint);

			if (tuicaiItem.m_is_taocan == true)
			{
				//开始保存套餐里面的商品详情，主要用于厨房打印

				//接下来要把这个套餐的详情也保存下来
				for (std::vector<CZhengcanOrderItem>::iterator it = tuicaiItem.m_taocan_items.begin(); it != tuicaiItem.m_taocan_items.end(); it++)
				{
					std::string food_id = it->food_id;

					//要根据商品ID找出商品的名字
					CFood foodinfo;
					CSqlite3 sqlite;
					bool is_found = sqlite.GetFoodById(food_id, foodinfo);
					if (!is_found)
					{
						continue;
					}

					CZhengcanOrderItemPrint foodpackageitemPrint;

					foodpackageitemPrint.m_food_name = foodinfo.name;
					foodpackageitemPrint.m_quantity = tuicaiItem.num;
					foodpackageitemPrint.m_item_price = foodinfo.price;
					foodpackageitemPrint.m_type_id = foodinfo.type_id;

					foodpackageitemPrint.is_taocan = false;
					foodpackageitemPrint.is_taocan_item = true;

					m_items_print.push_back(foodpackageitemPrint);
				}
			}
		}
	}
}

void CZhengcanOrder::UpdateItemPrintForTuicai(std::string tuicai_item_id)
{
	//清空之前的打印记录
	m_items_print.clear();

	for (std::vector<CZhengcanOrderHistoryXiadan>::iterator it = m_order_history_array.begin(); it != m_order_history_array.end(); it++)
	{
		for (std::vector<CZhengcanOrderItem>::iterator it1 = it->m_items.begin(); it1 != it->m_items.end(); it1++)
		{
			if (it1->item_id != tuicai_item_id)
			{
				//如果jiacai_no不想等，就直接忽略
				continue;
			}

			CZhengcanOrderItemPrint itemPrint;

			itemPrint.is_tuicai = true;

			CZhengcanOrderItem tuicaiItem = *it1;

			itemPrint.m_quantity = tuicaiItem.num;
			itemPrint.m_item_price = tuicaiItem.price;
			itemPrint.m_type_id = tuicaiItem.type_id;

			if (tuicaiItem.m_is_taocan == true)
			{
				itemPrint.is_taocan = true;

				itemPrint.m_food_name = tuicaiItem.foodpackage_name; //不带属性商品
			}
			else
			{
				itemPrint.m_food_name = tuicaiItem.food_name; //带属性值
			}

			m_items_print.push_back(itemPrint);

			if (tuicaiItem.m_is_taocan == true)
			{
				//开始保存套餐里面的商品详情，主要用于厨房打印

				//接下来要把这个套餐的详情也保存下来
				for (std::vector<CZhengcanOrderItem>::iterator it = tuicaiItem.m_taocan_items.begin(); it != tuicaiItem.m_taocan_items.end(); it++)
				{
					std::string food_id = it->food_id;

					//要根据商品ID找出商品的名字
					CFood foodinfo;
					CSqlite3 sqlite;
					bool is_found = sqlite.GetFoodById(food_id, foodinfo);
					if (!is_found)
					{
						continue;
					}

					CZhengcanOrderItemPrint foodpackageitemPrint;

					foodpackageitemPrint.m_food_name = foodinfo.name;
					foodpackageitemPrint.m_quantity = tuicaiItem.num;
					foodpackageitemPrint.m_item_price = foodinfo.price;
					foodpackageitemPrint.m_type_id = foodinfo.type_id;

					foodpackageitemPrint.is_taocan = false;
					foodpackageitemPrint.is_taocan_item = true;

					m_items_print.push_back(foodpackageitemPrint);
				}
			}
		}
	}
}