// Метод для обновления содержания заказа
public bool updateOrderContent(int client_id,
string present_order_consist,
string history_order_consist,
decimal order_worth)
{
try
{
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID = _Order_ID
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == _Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
order_info.FK_AOS_ID_CLIENT = client_id;
order_info.ORDER_PRESENT_CONSIST = present_order_consist;
order_info.ORDER_HISTORY_CONSIST = history_order_consist;
order_info.ORDER_WORTH = order_worth;
// Сохраняем данные
aos_db.SaveChanges();
}
}
// Если обновление заказа не удалось
catch (Exception)
{
return false;
}
return true;
}
// Конструктор
public Client(int client_id)
{
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с клиентами в БД с ID = client_id
AOS_KL_CLIENT client = new AOS_KL_CLIENT();
try
{
client =
(from item in
aos_db.AOS_KL_CLIENT.ToList<AOS_KL_CLIENT>()
.AsParallel<AOS_KL_CLIENT>()
where (item.PK_AOS_ID_CLIENT == client_id)
select item).Single();
// Если клиент с таким ID найден в БД
_Client_ID = client.PK_AOS_ID_CLIENT;
_Client_FIO = client.CLIENT_FIO;
_Client_Phone = client.CLIENT_PHONE;
}
// Если клиент с таким ID не найден в БД
catch (System.InvalidOperationException)
{
_Client_ID = 0;
_Client_FIO = "anonymous";
_Client_Phone = "none";
}
}
}
// Конструктор
public Product(int product_id)
{
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с продуктами в БД с ID = product_id
AOS_KL_PRODUCT product =
(from item in
aos_db.AOS_KL_PRODUCT.ToList<AOS_KL_PRODUCT>()
.AsParallel<AOS_KL_PRODUCT>()
where (item.PK_AOS_ID_PRODUCT == product_id)
select item).Single();
// Заполняем свойства класса
_Product_ID = product.PK_AOS_ID_PRODUCT;
Product_Name.Add("RU", product.PRODUCT_NAME_RU);
Product_Name.Add("EN", product.PRODUCT_NAME_EN);
_Product_Class = product.FK_AOS_ID_PRODUCT_CLASS;
Product_Info.Add("RU", product.PRODUCT_INFO_RU);
Product_Info.Add("EN", product.PRODUCT_INFO_EN);
Product_Recommendation.Add("RU", product.PRODUCT_RECOMMEND_RU);
Product_Recommendation.Add("EN", product.PRODUCT_RECOMMEND_EN);
Product_Consist.Add("RU", product.PRODUCT_CONSIST_RU);
Product_Consist.Add("EN", product.PRODUCT_CONSIST_EN);
_Product_Img_List.Add(Regex.Matches(product.PRODUCT_IMG_ID,
@"\w+_small.\w{3}")[0].ToString());
_Product_Img_List.Add(Regex.Matches(product.PRODUCT_IMG_ID,
@"\w+_0.\w{3}")[0].ToString());
_Product_Img_List.Add(Regex.Matches(product.PRODUCT_IMG_ID,
@"\w+_1.\w{3}")[0].ToString());
Product_Amount.Add("RU", product.PRODUCT_AMOUNT_RU);
Product_Amount.Add("EN", product.PRODUCT_AMOUNT_EN);
string dummy = product.PRODUCT_PRICE.ToString();
_Product_Price = dummy.Remove(dummy.Length - 3, 2);
}
}
public void dbReadWriteTest()
{
bool actual_result = false;
using (AOSDB aos_db = new AOSDB())
{
// Формируем объект класса AOS_KL_PRODUCT_CLASS
AOS_KL_PRODUCT_CLASS product_class = new AOS_KL_PRODUCT_CLASS();
product_class.PK_AOS_ID_PRODUCT_CLASS = 4;
product_class.PRODUCT_CLASS_NAME_RU = "Напитки";
product_class.PRODUCT_CLASS_NAME_EN = "Drinks";
// Добавляем объект и сохраняем его в БД
aos_db.AOS_KL_PRODUCT_CLASS.Add(product_class);
aos_db.SaveChanges();
// Проверяем добавилась ли строка в таблицу
// AOS_KL_PRODUCT_CLASS
foreach (var item in aos_db.AOS_KL_PRODUCT_CLASS)
if (item == product_class)
actual_result = true;
Assert.AreEqual(true, actual_result);
// Удаляем строку из БД
aos_db.AOS_KL_PRODUCT_CLASS.Remove(product_class);
aos_db.SaveChanges();
// Проверяем удалилась ли строка из таблицы
// AOS_KL_PRODUCT_CLASS
actual_result = false;
foreach (var item in aos_db.AOS_KL_PRODUCT_CLASS)
if (item == product_class)
actual_result = true;
Assert.AreNotEqual(true, actual_result);
}
}
// Конструктор
public Marketing()
{
using (AOSDB aos_db = new AOSDB())
{
Marketing_List =
(from item in
aos_db.AOS_BD_MARKETING
select item).ToList<AOS_BD_MARKETING>();
}
}
// Метод для возврата статуса заказа
public string getOrderState()
{
string order_state;
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID = _Order_ID
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == _Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
order_state = order_info.ORDER_STATE;
}
return order_state;
}
// Метод для возврата скидки клиента
public string getClientDiscount()
{
string client_discount;
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с клиентами в БД с ID = _Client_ID
AOS_KL_CLIENT client =
(from item in
aos_db.AOS_KL_CLIENT.ToList<AOS_KL_CLIENT>()
.AsParallel<AOS_KL_CLIENT>()
where (item.PK_AOS_ID_CLIENT == _Client_ID)
select item).Single();
client_discount = (client.CLIENT_DISCOUNT * 0.01).ToString();
}
return client_discount;
}
// Конструктор
public ProductClass(byte product_class_id)
{
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с категориями продуктов в
// БД с ID = product_class_id
AOS_KL_PRODUCT_CLASS product_class =
(from item in
aos_db.AOS_KL_PRODUCT_CLASS.ToList<AOS_KL_PRODUCT_CLASS>()
.AsParallel<AOS_KL_PRODUCT_CLASS>()
where (item.PK_AOS_ID_PRODUCT_CLASS == product_class_id)
select item).Single();
// Заполняем свойства класса
_Product_Class_ID = product_class.PK_AOS_ID_PRODUCT_CLASS;
Product_Class_Name.Add("RU", product_class.PRODUCT_CLASS_NAME_RU);
Product_Class_Name.Add("EN", product_class.PRODUCT_CLASS_NAME_EN);
}
}
// Метод для возврата списка продуктов в таблице с продуктами в БД,
// принадлежащих данной категории продуктов
public List<Product> getProductList()
{
List<Product> product_list = new List<Product>();
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с продуктами в БД с
// ID категории = product_class_id
List<AOS_KL_PRODUCT> dummy_product_list =
(from item in
aos_db.AOS_KL_PRODUCT.ToList<AOS_KL_PRODUCT>()
.AsParallel<AOS_KL_PRODUCT>()
where (item.FK_AOS_ID_PRODUCT_CLASS == _Product_Class_ID)
select item).ToList<AOS_KL_PRODUCT>();
// Создаем колекцию объектов класса Product для
// полученного списка
foreach (AOS_KL_PRODUCT item in dummy_product_list)
product_list.Add(new Product(item.PK_AOS_ID_PRODUCT));
}
return product_list;
}
// Конструктор
public Order(string menu_client_id, int client_id,
string present_order_consist, string history_order_consist,
decimal order_worth)
{
// Формируем данные заказа для сохранения в БД
AOS_BD_ORDER order = new AOS_BD_ORDER();
order.ORDER_EMENU_CLIENT_ID = menu_client_id;
order.FK_AOS_ID_CLIENT = client_id;
order.ORDER_DATE_TIME_BEGIN = DateTime.Now;
order.ORDER_DATE_TIME_END = DateTime.Now;
order.ORDER_PRESENT_CONSIST = present_order_consist;
order.ORDER_HISTORY_CONSIST = history_order_consist;
order.ORDER_STATE = "opened";
order.ORDER_WORTH = order_worth;
// Добавляем заказ в БД
using (AOSDB aos_db = new AOSDB())
{
aos_db.AOS_BD_ORDER.Add(order);
aos_db.SaveChanges();
_Order_ID = order.PK_AOS_ID_ORDER;
}
}
// Метод для расчета скидки клиента,
// исходя из общей суммы заказов клиента
public void setClientDiscount()
{
// Если клиент не аноним
if (_Client_ID != 0)
{
using (AOSDB aos_db = new AOSDB())
{
// Список сумм всех заказов клиента в БД
List<string> client_order_worth =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>().
AsParallel<AOS_BD_ORDER>()
where item.FK_AOS_ID_CLIENT == _Client_ID
select item.ORDER_WORTH.ToString()).ToList<string>();
// Сумма всех сумм заказов клиента
double client_order_sum = 0;
foreach (string item in client_order_worth)
client_order_sum += Convert.ToDouble(item);
// За каждые 10.000 рублей плюс 1% к скидке
byte discount_modifier = (byte)Math.Floor(client_order_sum / 10000);
// Находим элемент в таблице с клиентами в БД с ID = _Client_ID
AOS_KL_CLIENT client =
(from item in
aos_db.AOS_KL_CLIENT.ToList<AOS_KL_CLIENT>()
.AsParallel<AOS_KL_CLIENT>()
where (item.PK_AOS_ID_CLIENT == _Client_ID)
select item).Single();
// Устанавливаем новую скидку
client.CLIENT_DISCOUNT += discount_modifier;
aos_db.SaveChanges();
}
}
}
// Метод для сохранения рейта в БД
public bool setProductRate(byte product_rate)
{
try
{
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с рейтами БД с ID = _Product_ID
AOS_BD_PRODUCT_RATE product_rate_list =
(from item in
aos_db.AOS_BD_PRODUCT_RATE.ToList<AOS_BD_PRODUCT_RATE>()
.AsParallel<AOS_BD_PRODUCT_RATE>()
where (item.PK_AOS_ID_PRODUCT == _Product_ID)
select item).Single();
// В зависимости от product_rate сохраняем значение в БД
// в таблицу с рейтами
switch (product_rate)
{
case 0:
++product_rate_list.PRODUCT_RATE_0;
break;
case 1:
++product_rate_list.PRODUCT_RATE_1;
break;
case 2:
++product_rate_list.PRODUCT_RATE_2;
break;
case 3:
++product_rate_list.PRODUCT_RATE_3;
break;
case 4:
++product_rate_list.PRODUCT_RATE_4;
break;
case 5:
++product_rate_list.PRODUCT_RATE_5;
break;
default:
break;
}
aos_db.SaveChanges();
}
}
// Если не удалось сохранить рейт
catch (Exception)
{
return false;
}
return true;
}
// Метод для вызова сотрудника
public bool callStaff(string emenu_client_id, string employee_id)
{
try
{
using (AOSDB aos_db = new AOSDB())
{
// Формируем данные для для запроса на вызов сотрудника
AOS_BD_CALL_QUEUE call = new AOS_BD_CALL_QUEUE();
call.CALL_QUEUE_EMENU_CLIENT_ID = emenu_client_id;
call.FK_AOS_ID_CLIENT =
_Current_Client == null ? 0 : _Current_Client.Client_ID;
if (_Current_Order != null)
call.FK_AOS_ID_ORDER = _Current_Order.Order_ID;
call.CALL_QUEUE_DATE_TIME = DateTime.Now;
call.CALL_QUEUE_EMPLOYEE_ID = employee_id;
// Добавляем сообщение
aos_db.AOS_BD_CALL_QUEUE.Add(call);
aos_db.SaveChanges();
}
}
// Если вызов не удался
catch (Exception)
{
return false;
}
return true;
}
// Метод для поиска продуктов в меню
public List<Product> searchProduct(string search_word)
{
List<Product> product_list = new List<Product>();
search_word = search_word.ToLower();
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с продуктами в БД с,
// содержащие в имени search_word
List<AOS_KL_PRODUCT> dummy_product_list;
if (_lang_menu_flag == "RU")
dummy_product_list =
(from item in
aos_db.AOS_KL_PRODUCT.ToList<AOS_KL_PRODUCT>()
.AsParallel<AOS_KL_PRODUCT>()
where (item.PRODUCT_NAME_RU.ToLower().Contains(search_word))
select item).ToList<AOS_KL_PRODUCT>();
else
dummy_product_list =
(from item in
aos_db.AOS_KL_PRODUCT.ToList<AOS_KL_PRODUCT>()
.AsParallel<AOS_KL_PRODUCT>()
where (item.PRODUCT_NAME_EN.ToLower().Contains(search_word))
select item).ToList<AOS_KL_PRODUCT>();
// Создаем колекцию объектов класса Product для
// полученного списка
foreach (AOS_KL_PRODUCT item in dummy_product_list)
product_list.Add(new Product(item.PK_AOS_ID_PRODUCT));
}
return product_list;
}
// Метод для отправки сообщения
public bool sendMessage(string msg_destination, string message_body)
{
try
{
using (AOSDB aos_db = new AOSDB())
{
// Формируем данные для отправки сообщения
AOS_BD_MESSAGE message = new AOS_BD_MESSAGE();
message.FK_AOS_ID_CLIENT =
_Current_Client == null ? 0 : _Current_Client.Client_ID;
if (_Current_Order != null)
message.FK_AOS_ID_ORDER = _Current_Order.Order_ID;
message.MESSAGE_RECIVIER_ID = msg_destination;
message.MESSAGE_DATE_TIME = DateTime.Now;
message.MESSAGE_BODY = message_body;
// Добавляем сообщение
aos_db.AOS_BD_MESSAGE.Add(message);
aos_db.SaveChanges();
}
}
// Если отправка не удалась
catch (Exception)
{
return false;
}
return true;
}
// Метод для закрытия заказа
public void closeOrder()
{
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID = _Order_ID
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == _Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
order_info.ORDER_DATE_TIME_END = DateTime.Now;
order_info.ORDER_STATE = "ended";
order_info.ORDER_PRESENT_CONSIST = "";
// Сохраняем данные
aos_db.SaveChanges();
}
}
public void OrderTest()
{
// Тест конструктора
// Ожидаемые данные
string expected_menu_client_id = "1";
int expected_client_id = 23456;
string expected_present_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
'1' + '"' + "}]";
string expected_history_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
'6' + '"' + "}]";
string expected_order_state = "opened";
decimal expected_order_worth = 2100.00M;
// Создаем объект заказа
Order order = new Order(expected_menu_client_id, expected_client_id,
expected_present_order_consist, expected_history_order_consist,
expected_order_worth);
// Полученные данные
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID
// равным ID заказа
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == order.Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
// Утверждения
Assert.AreEqual(expected_menu_client_id, order_info.ORDER_EMENU_CLIENT_ID);
Assert.AreEqual(expected_client_id, order_info.FK_AOS_ID_CLIENT);
Assert.AreEqual(expected_present_order_consist,
order_info.ORDER_PRESENT_CONSIST);
Assert.AreEqual(expected_history_order_consist,
order_info.ORDER_HISTORY_CONSIST);
Assert.AreEqual(expected_order_state, order.getOrderState());
Assert.AreEqual(expected_order_worth, order_info.ORDER_WORTH);
}
// Тест обновления данных заказа
// Ожидаемые данные
expected_client_id = 34567;
expected_present_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
'6' + '"' + "}]";
expected_history_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
"12" + '"' + "}]";
expected_order_worth = 4200.00M;
// Обновляем данные о заказе
order.updateOrderContent(expected_client_id,
expected_present_order_consist,
expected_history_order_consist,
expected_order_worth);
// Полученные данные
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID
// равным ID заказа
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == order.Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
// Утверждения
Assert.AreEqual(expected_present_order_consist,
order_info.ORDER_PRESENT_CONSIST);
Assert.AreEqual(expected_history_order_consist,
order_info.ORDER_HISTORY_CONSIST);
Assert.AreEqual(expected_order_worth, order_info.ORDER_WORTH);
}
// Тест закрытия заказа
// Ожидаемые данные
expected_order_state = "ended";
// Закрываем заказ
order.closeOrder();
// Полученные данные
using (AOSDB aos_db = new AOSDB())
{
// Ищем заказ в таблице заказов в БД с ID
// равным ID заказа
AOS_BD_ORDER order_info =
(from item in
aos_db.AOS_BD_ORDER.ToList<AOS_BD_ORDER>()
.AsParallel<AOS_BD_ORDER>()
where item.PK_AOS_ID_ORDER == order.Order_ID
select item).ToList<AOS_BD_ORDER>().Single();
// Утверждения
Assert.AreEqual(expected_order_state, order.getOrderState());
// Очищаем БД от добавленного тестового значения
aos_db.AOS_BD_ORDER.Remove(order_info);
aos_db.SaveChanges();
}
}
public void ClientTest()
{
// Тест конструктора
// Ожидаемые данные, взяты из тестовой БД AOS.DB.test
int expected_client_id_1 = 23456;
string expected_client_fio_1 =
"Новиков Павел Николаевич";
string expected_client_phone_1 =
"+79084682576";
string expected_client_discount_1 = "0,05";
int expected_client_id_2 = 0;
string expected_client_fio_2 =
"anonymous";
string expected_client_phone_2 =
"none";
string expected_client_discount_2 = "1";
// Полученные данные
Client client_1 = new Client(23456);
int actual_client_id_1 =
client_1.Client_ID;
string actual_client_fio_1 =
client_1.Client_FIO;
string actual_client_phone_1 =
client_1.Client_Phone;
string actual_client_discount_1 =
client_1.getClientDiscount();
Client client_2 = new Client(2345689);
int actual_client_id_2 =
client_2.Client_ID;
string actual_client_fio_2 =
client_2.Client_FIO;
string actual_client_phone_2 =
client_2.Client_Phone;
string actual_client_discount_2 =
client_2.getClientDiscount();
// Утверждения
Assert.AreEqual(expected_client_id_1, actual_client_id_1);
Assert.AreEqual(expected_client_fio_1, actual_client_fio_1);
Assert.AreEqual(expected_client_phone_1, actual_client_phone_1);
Assert.AreEqual(expected_client_discount_1, actual_client_discount_1);
Assert.AreEqual(expected_client_id_2, actual_client_id_2);
Assert.AreEqual(expected_client_fio_2, actual_client_fio_2);
Assert.AreEqual(expected_client_phone_2, actual_client_phone_2);
Assert.AreEqual(expected_client_discount_2, actual_client_discount_2);
// Тест установки размера скидки
// Ожидаемые данные
expected_client_discount_1 = "0,08";
// Полученные данные
client_1.setClientDiscount();
actual_client_discount_1 =
client_1.getClientDiscount();
// Утверждения
Assert.AreEqual(expected_client_discount_1, actual_client_discount_1);
// Возвращаем значения в БД к прежним
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с клиентами в БД с ID = 23456
AOS_KL_CLIENT client =
(from item in
aos_db.AOS_KL_CLIENT.ToList<AOS_KL_CLIENT>()
.AsParallel<AOS_KL_CLIENT>()
where (item.PK_AOS_ID_CLIENT == 23456)
select item).Single();
// Возвращаем значение на старте теста
client.CLIENT_DISCOUNT = 5;
aos_db.SaveChanges();
}
}
public void ProductTest()
{
// Тест конструктора
// Ожидаемые значения (взяты из тестовой БД AOS.DB.test)
int expected_product_id = 5;
string expected_product_name_ru =
"Салат Мегаполис";
string expected_product_name_en =
"Salad Megapolis";
int expected_product_class = 1;
string expected_product_info_ru =
"Ломтики нежной телятины, помидоры, огурцы, "
+ "перец сладкий, листья салата, чеснок, заправлен "
+ "фирменным соусом.";
string expected_product_info_en =
"Slices of tender veal, tomatoes, cucumbers, "
+ "peppers, lettuce, garlic, filled with special sauce.";
string expected_product_recommend_ru =
"Ломтики нежной телятины, помидоры, огурцы, "
+ "перец сладкий, листья салата, чеснок, заправлен "
+ "фирменным соусом.";
string expected_product_recommend_en =
"Slices of tender veal, tomatoes, cucumbers, "
+ "peppers, lettuce, garlic, filled with special sauce.";
string expected_product_consist_ru =
"Ломтики нежной телятины, помидоры, огурцы, "
+ "перец сладкий, листья салата, чеснок, заправлен "
+ "фирменным соусом.";
string expected_product_consist_en =
"Slices of tender veal, tomatoes, cucumbers, "
+ "peppers, lettuce, garlic, filled with special sauce.";
List<string> expected_product_img_list = new List<string>();
expected_product_img_list.Add("megapolis_small.jpg");
expected_product_img_list.Add("megapolis_0.jpg");
expected_product_img_list.Add("megapolis_1.jpg");
byte expected_product_rate;
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с рейтами БД с ID = _Product_ID
AOS_BD_PRODUCT_RATE product_rate_list =
(from item in
aos_db.AOS_BD_PRODUCT_RATE.ToList<AOS_BD_PRODUCT_RATE>()
.AsParallel<AOS_BD_PRODUCT_RATE>()
where (item.PK_AOS_ID_PRODUCT == 5)
select item).Single();
// Считаем общий бал
int rate_sum = product_rate_list.PRODUCT_RATE_0 * (-1)
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2 * 2
+ product_rate_list.PRODUCT_RATE_3 * 3
+ product_rate_list.PRODUCT_RATE_4 * 4
+ product_rate_list.PRODUCT_RATE_5 * 5;
// Считаем количество раз, когда ставился рейт
int rate_count = product_rate_list.PRODUCT_RATE_0
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2
+ product_rate_list.PRODUCT_RATE_3
+ product_rate_list.PRODUCT_RATE_4
+ product_rate_list.PRODUCT_RATE_5;
expected_product_rate = (byte)Math.Ceiling((double)(rate_sum / rate_count));
}
string expected_product_amount_ru = "200 г";
string expected_product_amount_en = "200 g";
string expected_product_price = "350,00";
// Полученные значения
Product test_product = new Product(5);
int actual_product_id =
test_product.Product_ID;
string actual_product_name_ru =
test_product.getProductName("RU");
string actual_product_name_en =
test_product.getProductName("EN");
int actual_product_class =
test_product.Product_Class;
string actual_product_info_ru =
test_product.getProductInfo("RU");
string actual_product_info_en =
test_product.getProductInfo("EN");
string actual_product_recommend_ru =
test_product.getProductRecommendation("RU");
string actual_product_recommend_en =
test_product.getProductRecommendation("EN");
string actual_product_consist_ru =
test_product.getProductConsist("RU");
string actual_product_consist_en =
test_product.getProductConsist("EN");
List<string> actual_product_img_list =
test_product.Product_Img_List;
byte actual_product_rate =
test_product.getProductRate();
string actual_product_amount_ru =
test_product.getProductAmount("RU");
string actual_product_amount_en =
test_product.getProductAmount("EN");
string actual_product_price =
test_product.Product_Price;
// Утверждения
Assert.AreEqual(expected_product_id, actual_product_id);
Assert.AreEqual(expected_product_name_ru, actual_product_name_ru);
Assert.AreEqual(expected_product_name_en, actual_product_name_en);
Assert.AreEqual(expected_product_class, actual_product_class);
Assert.AreEqual(expected_product_info_ru, actual_product_info_ru);
Assert.AreEqual(expected_product_info_en, actual_product_info_en);
Assert.AreEqual(expected_product_recommend_ru, actual_product_recommend_ru);
Assert.AreEqual(expected_product_recommend_en, actual_product_recommend_en);
Assert.AreEqual(expected_product_consist_ru, actual_product_consist_ru);
Assert.AreEqual(expected_product_consist_en, actual_product_consist_en);
Assert.AreEqual(expected_product_img_list, actual_product_img_list);
Assert.AreEqual(expected_product_rate, actual_product_rate);
Assert.AreEqual(expected_product_amount_ru, actual_product_amount_ru);
Assert.AreEqual(expected_product_amount_en, actual_product_amount_en);
Assert.AreEqual(expected_product_price, actual_product_price);
// Тест установки нового рейта продукта
// Устанавливаем новый рейт продукта
test_product.setProductRate(0);
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с рейтами БД с ID = _Product_ID
AOS_BD_PRODUCT_RATE product_rate_list =
(from item in
aos_db.AOS_BD_PRODUCT_RATE.ToList<AOS_BD_PRODUCT_RATE>()
.AsParallel<AOS_BD_PRODUCT_RATE>()
where (item.PK_AOS_ID_PRODUCT == 5)
select item).Single();
// Считаем общий бал
int rate_sum = product_rate_list.PRODUCT_RATE_0 * (-1)
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2 * 2
+ product_rate_list.PRODUCT_RATE_3 * 3
+ product_rate_list.PRODUCT_RATE_4 * 4
+ product_rate_list.PRODUCT_RATE_5 * 5;
// Считаем количество раз, когда ставился рейт
int rate_count = product_rate_list.PRODUCT_RATE_0
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2
+ product_rate_list.PRODUCT_RATE_3
+ product_rate_list.PRODUCT_RATE_4
+ product_rate_list.PRODUCT_RATE_5;
expected_product_rate = (byte)Math.Ceiling((double)(rate_sum / rate_count));
}
actual_product_rate =
test_product.getProductRate();
// Утверждения
Assert.AreEqual(expected_product_rate, actual_product_rate);
}
// Метод для получения рейта продукта
public byte getProductRate()
{
byte Product_Rate = 0;
using (AOSDB aos_db = new AOSDB())
{
// Находим элемент в таблице с рейтами БД с ID = _Product_ID
AOS_BD_PRODUCT_RATE product_rate_list =
(from item in
aos_db.AOS_BD_PRODUCT_RATE.ToList<AOS_BD_PRODUCT_RATE>()
.AsParallel<AOS_BD_PRODUCT_RATE>()
where (item.PK_AOS_ID_PRODUCT == _Product_ID)
select item).Single();
// Считаем общий бал
int rate_sum = product_rate_list.PRODUCT_RATE_0 * (-1)
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2 * 2
+ product_rate_list.PRODUCT_RATE_3 * 3
+ product_rate_list.PRODUCT_RATE_4 * 4
+ product_rate_list.PRODUCT_RATE_5 * 5;
// Считаем количество раз, когда ставился рейт
int rate_count = product_rate_list.PRODUCT_RATE_0
+ product_rate_list.PRODUCT_RATE_1
+ product_rate_list.PRODUCT_RATE_2
+ product_rate_list.PRODUCT_RATE_3
+ product_rate_list.PRODUCT_RATE_4
+ product_rate_list.PRODUCT_RATE_5;
if (rate_count != 0)
Product_Rate = (byte)Math.Ceiling((double)(rate_sum / rate_count));
}
return Product_Rate;
}
public void MenuSessionTest_1()
{
// Тест конструктора
MenuSession menu_session =
new MenuSession();
// Переключаем язык
menu_session.switchMenuLang();
// Ожидаемые данные
string expected_lang_menu_flag = "EN";
// Полученные данные
string actual_lang_menu_flag =
menu_session.lang_menu_flag;
// Утверждения
Assert.AreEqual(expected_lang_menu_flag,
actual_lang_menu_flag);
// Переключаем язык
menu_session.switchMenuLang();
// Ожидаемые данные
expected_lang_menu_flag = "RU";
// Полученные данные
actual_lang_menu_flag =
menu_session.lang_menu_flag;
// Утверждения
Assert.AreEqual(expected_lang_menu_flag,
actual_lang_menu_flag);
// Тест авторизации клиента
// Ожидаемые данные
Client expected_client = new Client(0);
bool expected_auth_flag = false;
// Попытка авторизации в меню существующего клиента
bool actual_auth_flag = menu_session.tryUserAuth(12);
// Утверждения
Assert.AreEqual(expected_client.Client_FIO,
menu_session.Current_Client.Client_FIO);
Assert.AreEqual(expected_auth_flag, actual_auth_flag);
// Ожидаемые данные
expected_client = new Client(34567);
expected_auth_flag = true;
// Попытка авторизации в меню существующего клиента
actual_auth_flag = menu_session.tryUserAuth(34567);
// Утверждения
Assert.AreEqual(expected_client.Client_FIO,
menu_session.Current_Client.Client_FIO);
Assert.AreEqual(expected_auth_flag, actual_auth_flag);
// Тест создания заказа
// Ожидаемые данные
string expected_menu_client_id = "1";
int expected_client_id = menu_session.Current_Client.Client_ID;
string expected_present_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
'1' + '"' + "}]";
string expected_history_order_consist = "[{" + '"' + "id" + '"' + ":"
+ '"' + '5' + '"' + ',' + '"'
+ "count" + '"' + ':' + '"' +
'6' + '"' + "}]";
string expected_order_state = "opened";
decimal expected_order_worth = 2100.00M;
// Создаем заказ
menu_session.createOrder(expected_menu_client_id, expected_client_id,
expected_present_order_consist,
expected_history_order_consist,
expected_order_worth);
// Утверждения
Assert.AreEqual(expected_order_state,
menu_session.Current_Order.getOrderState());
// Тест отправки сообщения
// Ожидаемые данные
int expected_msg_client_id = 34567;
int expected_msg_order_id = menu_session.Current_Order.Order_ID;
string expected_msg_reciever = "cook";
string expected_msg_body = "Сообщене для повара";
// Посылаем сообщение
menu_session.sendMessage(expected_msg_reciever, expected_msg_body);
using (AOSDB aos_db = new AOSDB())
{
AOS_BD_MESSAGE message =
(from item in aos_db.AOS_BD_MESSAGE
select item).Single();
// Утверждения
Assert.AreEqual(expected_msg_client_id,
message.FK_AOS_ID_CLIENT);
Assert.AreEqual(expected_msg_order_id,
message.FK_AOS_ID_ORDER);
Assert.AreEqual(expected_msg_reciever,
message.MESSAGE_RECIVIER_ID);
Assert.AreEqual(expected_msg_body,
message.MESSAGE_BODY);
// Очищаем таблицу от тестовых данных
aos_db.AOS_BD_MESSAGE.Remove(message);
aos_db.SaveChanges();
}
// Тест запроса на вызов сотрудника
// Ожидаемые данные
string expected_emenu_client_id = "0.1apb5njklfp";
int expected_call_client_id = 34567;
int expected_call_order_id = menu_session.Current_Order.Order_ID;
string expected_employee_id = "admin";
// Посылаем запрос на вызов сотрудника
menu_session.callStaff(expected_emenu_client_id,
expected_employee_id);
using (AOSDB aos_db = new AOSDB())
{
AOS_BD_CALL_QUEUE call =
(from item in aos_db.AOS_BD_CALL_QUEUE
select item).Single();
// Утверждения
Assert.AreEqual(expected_emenu_client_id,
call.CALL_QUEUE_EMENU_CLIENT_ID);
Assert.AreEqual(expected_call_client_id,
call.FK_AOS_ID_CLIENT);
Assert.AreEqual(expected_call_order_id,
call.FK_AOS_ID_ORDER);
Assert.AreEqual(expected_employee_id,
call.CALL_QUEUE_EMPLOYEE_ID);
// Очищаем таблицу от тестовых данных
aos_db.AOS_BD_CALL_QUEUE.Remove(call);
aos_db.SaveChanges();
}
// Просим счет
menu_session.getBill();
}