#include <string>
#include<vector>
#include <ctime>
#include <iterator>
#include <Windows.h>
 
#define LUA_LIB
#define LUA_BUILD_AS_DLL
 
extern "C" {
#include "Lua/lauxlib.h"
#include "Lua/lua.h"
#include "Lua/luaconf.h"
}
 
 
enum class ExpiryType
{
 GTC = 0,
 TODAY = 1,
 DT = 2
};
struct ExpiryDate
{
 tm DT;
 ExpiryType type;
};
 
struct DB_QueryParams
{
 std::string class_code;
 std::string sec_code;
 std::string account;
};
 
enum class order_Action
{
 NEW_ORDER,//новая заявка
 NEW_NEG_DEAL, //новая заявка на внебиржевую сделку
 NEW_REPO_NEG_DEAL, //новая заявка на сделку РЕПО
 NEW_EXT_REPO_NEG_DEAL, //новая заявка на сделку модифицированного РЕПО (РЕПО-М)
 NEW_STOP_ORDER, //новая стоп-заявка
 KILL_ORDER, //снять заявку
 KILL_NEG_DEAL, //снять заявку на внебиржевую сделку или заявку на сделку РЕПО
 KILL_STOP_ORDER, //снять стоп-заявку
 KILL_ALL_ORDERS, //снять все заявки из торговой системы
 KILL_ALL_STOP_ORDERS, //снять все стоп-заявки
 KILL_ALL_NEG_DEALS, //снять все заявки на внебиржевые сделки и заявки на сделки РЕПО
 KILL_ALL_FUTURES_ORDERS, //снять все заявки на рынке FORTS
 MOVE_ORDERS, //переставить заявки на рынке FORTS
 NEW_QUOTE, //новая безадресная заявка
 KILL_QUOTE, //снять безадресную заявку
 NEW_REPORT, //новая заявка-отчет о подтверждении транзакций в режимах РПС и РЕПО
 SET_FUT_LIMIT, //новое ограничение по фьючерсному счету
};
enum class order_Type
{
 L, //limit
 M //market
};
enum class order_Operation
{
 B, //bue
 S //sell
};
enum class order_Execution_condition
{
 PUT_IN_QUEUE, //поставить в очередь (по умолчанию)
 FILL_OR_KILL, //немедленно или отклонить
 KILL_BALANCE, //снять остаток
};
enum class order_Stop_order_kind
{
 SIMPLE_STOP_ORDER, //стоп-лимит
 CONDITION_PRICE_BY_OTHER_SEC, //с условием по другой бумаге
 WITH_LINKED_LIMIT_ORDER, //со связанной заявкой
 TAKE_PROFIT_STOP_ORDER, //тэйк-профит
 TAKE_PROFIT_AND_STOP_LIMIT_ORDER, //тэйк-профит и стоп-лимит
 ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER, //стоп-лимит по исполнению заявки
 ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER, //тэйк-профит по исполнению заявки
 ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER //тэйк-профит и стоп-лимит по исполнению заявки
};
enum class order_Stopprice_condition
{
 less_or_equal,
 more_or_ewual
};
struct order_TimeStruct
{
 int hour;
 int min;
 int sec;
};
enum class order_For_account
{
 OWNOWN, //от своего имени, за свой счет
 OWNCLI, //от своего имени, за счет клиента
 OWNDUP, //от своего имени, за счет доверительного управления
 CLICLI, //от имени клиента, за счет клиента
};
enum class order_Units
{
 PERCENTS, //в процентах (шаг изменения – одна сотая процента)
 PRICE_UNITS // в параметрах цены(шаг изменения равен шагу цены по данному инструменту)
};
enum class order_Mode
{
 _0, //оставить количество в заявках без изменения,
 _1, //изменить количество в заявках на новые,
 _2 //при несовпадении новых количеств с текущим хотя бы в одной заявке, обе заявки снимаются
};
 
struct Ttransaction
{
public:
 Ttransaction(lua_State *L, DB_QueryParams params);
 Ttransaction(const Ttransaction &other);
 ~Ttransaction();
 
 void classcode();
 void seccode();
 void classcode(std::string param);
 void seccode(std::string param);
 void action(order_Action param);
 void firm_ID(std::string param);
 void account();
 void account(std::string param);
 void client_code(std::string param); // 20 symb - max
 void type(order_Type param);
 void market_maker_order(bool param);
 void operation(order_Operation param);
 void execution_condition(order_Execution_condition param);
 void quantity(int param);
 void repovalue(double param);
 void start_discount(double param);
 void lower_discount(double param);
 void upper_discount(double param);
 void price(double param);
 void stopprice(double param);
 void stop_order_kind(order_Stop_order_kind param);
 void stopprice_classcode(std::string param);
 void stopprice_seccode(std::string param);
 void stopprice_condition(order_Stopprice_condition param);
 void linked_order_price(double param);
 void expiry_date(ExpiryDate param);
 void stopprice2(double param);
 void market_stop_limit(bool param);
 void market_take_profit(bool param);
 void is_active_in_time(bool param);
 void active_from_time(order_TimeStruct param);
 void active_to_time(order_TimeStruct param);
 void partner(std::string param);
 void order_key(long param);
 void stop_order_key(long param);
 int trans_id();
 void trans_id(int param);
 void settle_code(std::string param);
 void price2(double param);
 void repoterm(std::string param);
 void reporate(double param);
 void block_securities(bool param);
 void refundrate(double param);
 void comment(std::string param);
 void large_trade(bool param);
 void curr_code(std::string param);
 void for_account(order_For_account param);
 void settle_date(tm param);
 void kill_if_linked_order_partly_field(bool param);
 void offset(double param, order_Units units);
 void spread(double param, order_Units units);
 void base_order_key(long param);
 void use_base_order_balance(bool param);
 void activate_if_base_order_partly_fielled(bool param);
 void base_contract(std::string param);
 void mode(order_Mode param);
 void first_order_number(long param);
 void first_order_new_quantity(int param);
 void first_order_new_price(double param);
 void second_order_number(long param);
 void second_order_new_quantity(int param);
 void second_order_new_price(double param);
 void kill_active_orders(bool param);
 void neg_trade_operation(order_Operation param);
 void neg_trade_number(std::string param);
 void volumemn(std::string param);
 void volumepl(std::string param);
 void kfl(double param);
 void kgo(double param);
 void use_kgo(bool param);
 void check_limits(bool param);
 void matchref(std::string param);
 void correction(bool param);
 
 //void reset_Table(int args_num);
 void reset_Table(DB_QueryParams params);
 
private:
 struct param_value
 {
 std::string fieldName;
 std::string arg;
 };
 
 lua_State *L;
 int scale;
 double price_step;
 std::vector<param_value> param_keeper;
 DB_QueryParams params;
 
 friend std::string sendTransaction(Ttransaction& T);
 
 std::string get_correctPrice(double price);
 void add_or_replace_field(std::string fieldName, std::string arg); // проверяет есть ли в fieldRows, если есть то заменяет, если нет то добовляет новое и добавляет в fieldRows
};

#include "Ttransaction.h"
//=================================================================================================================================================================================
//	Ttransaction
//=================================================================================================================================================================================
 
void Ttransaction::offset(double param, order_Units units)
{
	std::string data_param, data_units;
	if (units == order_Units::PRICE_UNITS)
	{
		data_param = get_correctPrice(param);
		data_units = "PRICE_UNITS";
	}
	else
	{
		data_param = std::to_string(param);
		data_units = "PERCENTS";
	}
	add_or_replace_field("OFFSET", data_param);
	add_or_replace_field("OFFSET_UNITS", data_units);
}
 
void Ttransaction::spread(double param, order_Units units)
{
	std::string data_param, data_units;
	if (units == order_Units::PRICE_UNITS)
	{
		data_param = get_correctPrice(param);
		data_units = "PRICE_UNITS";
	}
	else
	{
		data_param = std::to_string(param);
		data_units = "PERCENTS";
	}
	add_or_replace_field("SPREAD", data_param);
	add_or_replace_field("SPREAD_UNITS", data_units);
}
 
void Ttransaction::base_order_key(long param)
{
	add_or_replace_field("BASE_ORDER_KEY", std::to_string(param));
}
 
void Ttransaction::use_base_order_balance(bool param)
{
	add_or_replace_field("USE_BASE_ORDER_BALANCE", (param ? "YES" : "NO"));
}
 
void Ttransaction::activate_if_base_order_partly_fielled(bool param)
{
	add_or_replace_field("ACTIVATE_IF_BASE_ORDER_PARTLY_FILLED", (param ? "YES" : "NO"));
}
 
void Ttransaction::base_contract(std::string param)
{
	add_or_replace_field("BASE_CONTRACT", param);
}
 
void Ttransaction::mode(order_Mode param)
{
	std::string data;
	switch (param)
	{
	case order_Mode::_0: data = "0"; break;
	case order_Mode::_1: data = "1"; break;
	case order_Mode::_2: data = "2";  break;
	default: data = ""; break;
	}
 
	add_or_replace_field("MODE", data);
}
 
void Ttransaction::first_order_number(long param)
{
	add_or_replace_field("FIRST_ORDER_NUMBER", std::to_string(param));
}
 
void Ttransaction::first_order_new_quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("FIRST_ORDER_NEW_QUANTITY", std::to_string(param));
}
 
void Ttransaction::first_order_new_price(double param)
{
	add_or_replace_field("FIRST_ORDER_NEW_PRICE", get_correctPrice(param));
}
 
void Ttransaction::second_order_number(long param)
{
	add_or_replace_field("SECOND_ORDER_NUMBER", std::to_string(param));
}
 
void Ttransaction::second_order_new_quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("SECOND_ORDER_NEW_QUANTITY", std::to_string(param));
}
 
void Ttransaction::second_order_new_price(double param)
{
	add_or_replace_field("SECOND_ORDER_NEW_PRICE", std::to_string(param));
}
 
void Ttransaction::kill_active_orders(bool param)
{
	add_or_replace_field("KILL_ACTIVE_ORDERS", (param ? "YES" : "NO"));
}
 
void Ttransaction::neg_trade_operation(order_Operation param)
{
	std::string data;
	switch (param)
	{
	case order_Operation::B: data = "B"; break;
	case order_Operation::S: data = "S"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("NEG_TRADE_OPERATION", data);
}
 
void Ttransaction::neg_trade_number(std::string param)
{
	add_or_replace_field("NEG_TRADE_NUMBER", param);
}
 
void Ttransaction::volumemn(std::string param)
{
	add_or_replace_field("VOLUMEMN", param);
}
 
void Ttransaction::volumepl(std::string param)
{
	add_or_replace_field("VOLUMEPL", param);
}
 
void Ttransaction::kfl(double param)
{
	add_or_replace_field("KFL", std::to_string(param));
}
 
void Ttransaction::kgo(double param)
{
	add_or_replace_field("KGO", std::to_string(param));
}
 
void Ttransaction::use_kgo(bool param)
{
	add_or_replace_field("USE_KGO", (param ? "Y" : "N"));
}
 
void Ttransaction::check_limits(bool param)
{
	add_or_replace_field("CHECK_LIMITS", (param ? "YES" : "NO"));
}
 
void Ttransaction::matchref(std::string param)
{
	add_or_replace_field("MATCHREF", param);
}
 
void Ttransaction::correction(bool param)
{
	add_or_replace_field("CORRECTION", (param ? "Y" : "N"));
}
 
std::string Ttransaction::get_correctPrice(double price)
{
	price = round(price / price_step)*price_step;
	std::string data = std::to_string(price);
	std::string ans;
	bool is_next_step = false;
	std::string to_add;
 
	int _dot = -1;
	for (int i = 0; i < (int)data.size(); i++)
	{
		if(data.at(i) == '.' || data.at(i) == ',')
		{
			if (!is_next_step)
				is_next_step = true;
			continue;
		}
 
		if (is_next_step)
		{
			if (scale > 0)
				to_add.push_back(data.at(i));
			else
				break;
		}
		else
			ans.push_back(data.at(i));
	}
 
	if (scale > 0)
	{
		int to_add_size = to_add.size();
		ans.push_back('.');
		for (size_t i = 0; i < scale; i++)
		{
			if (i < to_add_size && to_add_size >0)
				ans.push_back(to_add.at(i));
			else
				ans.push_back('0');
		}
	}
	return ans;
}
 
void Ttransaction::add_or_replace_field(std::string fieldName, std::string arg)
{
	if (arg.compare("") != 0)
	{
		bool insert = true;
		for (size_t i = 0; i < param_keeper.size(); i++)
		{
			if (param_keeper[i].fieldName.compare(fieldName) == 0)
			{
				param_keeper[i].arg = arg;
				insert = false;
			}
		}
		if (insert)
		{
			param_value S;
			S.fieldName = fieldName;
			S.arg = arg;
			param_keeper.push_back(S);
		}
	}
}
 
Ttransaction::Ttransaction(lua_State * L, DB_QueryParams params)
{
	this->L = L;
 
	reset_Table(params);
}
 
Ttransaction::~Ttransaction()
{
}
 
void Ttransaction::classcode()
{
	add_or_replace_field("CLASSCODE", params.class_code);
}
 
void Ttransaction::seccode()
{
	add_or_replace_field("SECCODE", params.sec_code);
}
 
void Ttransaction::classcode(std::string param)
{
	add_or_replace_field("CLASSCODE", param);
}
 
void Ttransaction::seccode(std::string param)
{
	add_or_replace_field("SECCODE", param);
}
 
void Ttransaction::action(order_Action param)
{
	std::string data;
 
	switch (param)
	{
	case order_Action::NEW_ORDER: data = "NEW_ORDER"; break;
	case order_Action::NEW_NEG_DEAL: data = "NEW_NEG_DEAL"; break;
	case order_Action::NEW_REPO_NEG_DEAL: data = "NEW_REPO_NEG_DEAL"; break;
	case order_Action::NEW_EXT_REPO_NEG_DEAL: data = "NEW_EXT_REPO_NEG_DEAL"; break;
	case order_Action::NEW_STOP_ORDER: data = "NEW_STOP_ORDER"; break;
	case order_Action::KILL_ORDER: data = "KILL_ORDER"; break;
	case order_Action::KILL_NEG_DEAL: data = "KILL_NEG_DEAL"; break;
	case order_Action::KILL_STOP_ORDER: data = "KILL_STOP_ORDER"; break;
	case order_Action::KILL_ALL_ORDERS: data = "KILL_ALL_ORDERS"; break;
	case order_Action::KILL_ALL_STOP_ORDERS: data = "KILL_ALL_STOP_ORDERS"; break;
	case order_Action::KILL_ALL_NEG_DEALS: data = "KILL_ALL_NEG_DEALS"; break;
	case order_Action::KILL_ALL_FUTURES_ORDERS: data = "KILL_ALL_FUTURES_ORDERS"; break;
	case order_Action::MOVE_ORDERS: data = "MOVE_ORDERS"; break;
	case order_Action::NEW_QUOTE: data = "NEW_QUOTE"; break;
	case order_Action::KILL_QUOTE: data = "KILL_QUOTE"; break;
	case order_Action::NEW_REPORT: data = "NEW_REPORT"; break;
	case order_Action::SET_FUT_LIMIT: data = "SET_FUT_LIMIT"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("ACTION", data);
}
 
void Ttransaction::firm_ID(std::string param)
{
	add_or_replace_field("FIRM_ID", param);
}
 
void Ttransaction::account()
{
	add_or_replace_field("ACCOUNT", params.account);
}
 
void Ttransaction::account(std::string param)
{
	add_or_replace_field("ACCOUNT", param);
}
 
void Ttransaction::client_code(std::string param)
{
	add_or_replace_field("CLIENT_CODE", param);
}
 
void Ttransaction::type(order_Type param)
{
	std::string data;
 
	switch (param)
	{
	case order_Type::L: data = "L"; break;
	case order_Type::M: data = "M"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("TYPE", data);
}
 
void Ttransaction::market_maker_order(bool param)
{
	add_or_replace_field("MARKET_MAKER_ORDER", (param ? "YES" : "NO"));
}
 
void Ttransaction::operation(order_Operation param)
{
	std::string data;
	switch (param)
	{
	case order_Operation::B: data = "B"; break;
	case order_Operation::S: data = "S"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("OPERATION", data);
}
 
void Ttransaction::execution_condition(order_Execution_condition param)
{
	std::string data;
	switch (param)
	{
	case order_Execution_condition::PUT_IN_QUEUE: data = "PUT_IN_QUEUE"; break;
	case order_Execution_condition::FILL_OR_KILL: data = "FILL_OR_KILL"; break;
	case order_Execution_condition::KILL_BALANCE: data = "KILL_BALANCE"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("EXECUTION_CONDITION", data);
}
 
void Ttransaction::quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("QUANTITY", std::to_string(param));
}
 
void Ttransaction::repovalue(double param)
{
	add_or_replace_field("REPOVALUE", std::to_string(param));
}
 
void Ttransaction::start_discount(double param)
{
	add_or_replace_field("START_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::lower_discount(double param)
{
	add_or_replace_field("LOWER_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::upper_discount(double param)
{
	add_or_replace_field("UPPER_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::price(double param)
{
	add_or_replace_field("PRICE", get_correctPrice(param));
}
 
void Ttransaction::stopprice(double param)
{
	add_or_replace_field("STOPPRICE", get_correctPrice(param));
}
 
void Ttransaction::stop_order_kind(order_Stop_order_kind param)
{
	std::string data;
	switch (param)
	{
	case order_Stop_order_kind::SIMPLE_STOP_ORDER: data = "SIMPLE_STOP_ORDER"; break;
	case order_Stop_order_kind::CONDITION_PRICE_BY_OTHER_SEC: data = "CONDITION_PRICE_BY_OTHER_SEC"; break;
	case order_Stop_order_kind::WITH_LINKED_LIMIT_ORDER: data = "WITH_LINKED_LIMIT_ORDER"; break;
	case order_Stop_order_kind::TAKE_PROFIT_STOP_ORDER: data = "TAKE_PROFIT_STOP_ORDER"; break;
	case order_Stop_order_kind::TAKE_PROFIT_AND_STOP_LIMIT_ORDER: data = "TAKE_PROFIT_AND_STOP_LIMIT_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER: data = "ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER: data = "ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER: data = "ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("STOP_ORDER_KIND", data);
}
 
void Ttransaction::stopprice_classcode(std::string param)
{
	add_or_replace_field("STOPPRICE_CLASSCODE", param);
}
 
void Ttransaction::stopprice_seccode(std::string param)
{
	add_or_replace_field("STOPPRICE_SECCODE", param);
}
 
void Ttransaction::stopprice_condition(order_Stopprice_condition param)
{
	std::string data;
	switch (param)
	{
	case order_Stopprice_condition::less_or_equal: data = "<="; break;
	case order_Stopprice_condition::more_or_ewual: data = ">="; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("STOPPRICE_CONDITION", data);
}
 
void Ttransaction::linked_order_price(double param)
{
	add_or_replace_field("LINKED_ORDER_PRICE", get_correctPrice(param));
}
 
void Ttransaction::expiry_date(ExpiryDate param)
{
	bool add = true;
	std::string data;
	switch (param.type)
	{
	case ExpiryType::GTC: data = "GTC"; break;
	case ExpiryType::TODAY: data = "TODAY"; break;
	default:
	{
		char DT[100];
		if (std::strftime(DT, sizeof(DT), "%Y%m%d", &param.DT))
			data = DT;
		else
			add = false;
	}
	break;
	}
 
	if (add)
		add_or_replace_field("EXPIRY_DATE", data);
}
 
void Ttransaction::stopprice2(double param)
{
	add_or_replace_field("STOPPRICE2", get_correctPrice(param));
}
 
void Ttransaction::market_stop_limit(bool param)
{
	add_or_replace_field("MARKET_STOP_LIMIT", (param ? "YES" : "NO"));
}
 
void Ttransaction::market_take_profit(bool param)
{
	add_or_replace_field("MARKET_TAKE_PROFIT", (param ? "YES" : "NO"));
}
 
void Ttransaction::is_active_in_time(bool param)
{
	add_or_replace_field("IS_ACTIVE_IN_TIME", (param ? "YES" : "NO"));
}
 
void Ttransaction::active_from_time(order_TimeStruct param)
{
	auto get_num = [](double num)
	{
		return (num < 10 ? "0" + std::to_string(num) : std::to_string(num));
	};
	std::string data = get_num(param.hour) + get_num(param.min) + get_num(param.sec);
 
	add_or_replace_field("ACTIVE_FROM_TIME", data);
}
 
void Ttransaction::active_to_time(order_TimeStruct param)
{
	auto get_num = [](double num)
	{
		return (num < 10 ? "0" + std::to_string(num) : std::to_string(num));
	};
	std::string data = get_num(param.hour) + get_num(param.min) + get_num(param.sec);
 
	add_or_replace_field("ACTIVE_TO_TIME", data);
}
 
void Ttransaction::partner(std::string param)
{
	add_or_replace_field("PARTNER", param);
}
 
void Ttransaction::order_key(long param)
{
	add_or_replace_field("ORDER_KEY", std::to_string(param));
}
 
void Ttransaction::stop_order_key(long param)
{
	add_or_replace_field("STOP_ORDER_KEY", std::to_string(param));
}
 
int Ttransaction::trans_id()
{
	srand((unsigned int)time(NULL)); //seeding for the first time only!
	int num = (1 + rand() % ((2147483647 + 1) - 1));
 
	add_or_replace_field("TRANS_ID", std::to_string(num));
	return num;
}
 
void Ttransaction::trans_id(int param)
{
	if (param < 0) param = abs(param);
	add_or_replace_field("TRANS_ID", std::to_string(param));
}
 
void Ttransaction::settle_code(std::string param)
{
	add_or_replace_field("SETTLE_CODE", param);
}
 
void Ttransaction::price2(double param)
{
	add_or_replace_field("PRICE2", get_correctPrice(param));
}
 
void Ttransaction::repoterm(std::string param)
{
	add_or_replace_field("REPOTERM", param);
}
 
void Ttransaction::reporate(double param)
{
	add_or_replace_field("REPORATE", std::to_string(param));
}
 
void Ttransaction::block_securities(bool param)
{
	add_or_replace_field("BLOCK_SECURITIES", (param ? "YES" : "NO"));
}
 
void Ttransaction::refundrate(double param)
{
	add_or_replace_field("REFUNDRATE", std::to_string(param));
}
 
void Ttransaction::comment(std::string param)
{
	add_or_replace_field("COMMENT", param);
}
 
void Ttransaction::large_trade(bool param)
{
	add_or_replace_field("LARGE_TRADE", (param ? "YES" : "NO"));
}
 
void Ttransaction::curr_code(std::string param)
{
	add_or_replace_field("CURR_CODE", param);
}
 
void Ttransaction::for_account(order_For_account param)
{
	std::string data;
	switch (param)
	{
	case order_For_account::OWNOWN: data = "OWNOWN"; break;
	case order_For_account::OWNCLI: data = "OWNCLI"; break;
	case order_For_account::OWNDUP: data = "OWNDUP"; break;
	case order_For_account::CLICLI: data = "CLICLI"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("FOR_ACCOUNT", data);
}
 
void Ttransaction::settle_date(tm param)
{
	char DT[100];
	if (std::strftime(DT, sizeof(DT), "%Y%m%d", &param))
	{
		add_or_replace_field("SETTLE_DATE", DT);
	}
}
 
void Ttransaction::kill_if_linked_order_partly_field(bool param)
{
	add_or_replace_field("KILL_IF_LINKED_ORDER_PARTLY_FILLED", (param ? "YES" : "NO"));
}
 
std::string sendTransaction(Ttransaction & T)
{
 
	std::string ans;
 
	int length = (int)T.param_keeper.size();
 
	lua_settop(T.L, 0);
	lua_getglobal(T.L, "sendTransaction"); // 1 -2
	lua_createtable(T.L, 0, length);
 
	for (int i = 0; i < length; i++)
	{
		lua_pushfstring(T.L, T.param_keeper[i].arg.c_str());
		lua_setfield(T.L, -2, T.param_keeper[i].fieldName.c_str());
	}
 
	lua_call(T.L, 1, 1);
 
	if (lua_isnil(T.L, -1) || lua_tostring(T.L, -1) == "")
		ans = "";
	else
		ans = lua_tostring(T.L, -1);
 
	return ans;
}
 
void Ttransaction::reset_Table(DB_QueryParams params)
{
	lua_settop(L, 0);
 
	this->params = params;
	if (param_keeper.size() > 0)
		param_keeper.clear();
 
	lua_getglobal(L, "getSecurityInfo");
	lua_pushfstring(L, params.class_code.c_str());
	lua_pushfstring(L, params.sec_code.c_str());
 
	lua_call(L, 2, 1);
	lua_getfield(L, -1, "scale");
	scale = (int)lua_tonumber(L, -1);
 
	lua_settop(L, 0);
 
	lua_getglobal(L, "getParamEx");
	lua_pushfstring(L, params.class_code.c_str());
	lua_pushfstring(L, params.sec_code.c_str());
	lua_pushfstring(L, "SEC_PRICE_STEP");
 
	lua_call(L, 3, 1);
	lua_getfield(L, -1, "param_value");
	price_step = lua_tonumber(L, -1);
}
 
Ttransaction::Ttransaction(const Ttransaction & other)
{
	this->L = other.L;
	this->scale = other.scale;
	this->price_step = other.price_step;
	this->params = other.params;
 
	this->param_keeper.reserve(other.param_keeper.size());
	std::copy(other.param_keeper.begin(), other.param_keeper.end(), std::back_inserter(this->param_keeper));
}

#include "Ttransaction.h"
 
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
 return TRUE;
}
 
void msg_ToQuik(lua_State *L, std::string msg, int num)
{
 lua_settop(L, 0);
 
 lua_getglobal(L, "message");
 lua_pushfstring(L, msg.c_str());
 lua_pushnumber(L, num);
 lua_call(L, 2, 0);
}
 
void market_order(lua_State *L, DB_QueryParams params, order_Operation operation, double borderPrice, int qty)
{
 Ttransaction T(L, params);
 
 T.trans_id();
 T.account();
 T.classcode();
 T.seccode();
 T.action(order_Action::NEW_ORDER);
 T.type(borderPrice == 0 ? order_Type::M : order_Type::L);
 T.operation(operation);
 T.price(borderPrice);
 T.quantity(qty);
 
 std::string res = sendTransaction(T);
 if (res.compare("") != 0) 
 {
 msg_ToQuik(L, res, 3);
 }
 
}
 
int _main(lua_State *L)
{
 
 DB_QueryParams params;
 params.account = "NL0011100043";
 params.class_code = "QJSIM";
 params.sec_code = "ROSN";
 
 market_order(L, params, order_Operation::S, 313.15, 1);
 
 return 0;
}
 
static struct luaL_reg ls_lib[] = {
 { NULL, NULL }
};
extern "C" LUALIB_API int luaopen_Project2(lua_State *L)
{
 
 lua_pushcfunction(L, _main);
 lua_setglobal(L, "main");
 
 return 0;
}

require("ProjectName"); 

--/*НАСТРАИВАЕМЫЕ ПАРАМЕТРЫ*/
NAME_OF_STRATEGY = 'Str1_' -- НАЗВАНИЕ СТРАТЕГИИ (не более 9 символов!)
CLASS_CODE = "QJSIM" -- Код класса SPBFUT
SEC_CODE = "SBER" -- Код бумаги SiZ6 SiH7, SiM7, SiU7
ACCOUNT = "NL0011100043" -- Идентификатор счета SPBFUT00355
CLIENT_CODE = NAME_OF_STRATEGY..SEC_CODE -- "Код клиента"
QTY_LOTS = "1" -- Кол-во торгуемых лотов
FILE_LOG_NAME = "C:\\TRADING\\QUIK Junior\\Scripts\\Log.txt" -- ИМЯ ЛОГ-ФАЙЛА
 
--/*РАБОЧИЕ ПЕРЕМЕННЫЕ РОБОТА (менять не нужно)*/
g_price_step = 0 -- ШАГ ЦЕНЫ ИНСТРУМЕНТА
g_trans_id_entry = 110001 -- Задает начальный номер ID транзакций на вход
g_trans_id_exit = 220001 -- Задает начальный номер ID транзакций на выход
g_arrTransId_entry = {} -- массив ID транзакций на вход
g_arrTransId_exit = {} -- массив ID транзакций на выход
g_transId_del_order = "1234" -- ID ордера на удаление заявки (не меняется)
g_transId_del_stopOrder = "6789" -- ID ордера на удаление стоп заявки (не меняется)
g_currentPosition = 0 -- в позиции? сколько лотов и какое направление
g_IsTrallingStop = false -- выставлен ли трейлинг стоп на сервере
g_stopOrderEntry_num= "" -- номер стоп-заявки на вход в системе, по которому её можно снять
g_stopOrderExit_num = "" -- номер стоп-заявки на выход в системе, по которому её можно снять
g_order_num = "" -- номер заявки в системе, по которому её можно снять
g_oldTrade_num = "" -- номер предыдущей обработанной сделки
g_previous_time = os.time() -- помещение в переменную времени сервера в формате HHMMSS 
isRun = true -- Флаг поддержания работы бесконечного цикла в main
 
function OnInit()
   -- Получает ШАГ ЦЕНЫ ИНСТРУМЕНТА
    g_price_step = getParamEx(CLASS_CODE, SEC_CODE, "SEC_PRICE_STEP").param_value
 
    f = io.open(FILE_LOG_NAME, "a+") -- открывает файл 
    myLog("Initialization finished")
end
function main()
   g_trans_id_exit = g_trans_id_exit + 1
   g_arrTransId_exit[#g_arrTransId_exit+1] = g_trans_id_exit
 
   SendStopOrder("131.9", QTY_LOTS, "B", g_trans_id_exit) -- Отправить стоп ордер
   sleep(2000)                                            -- через 2 секунды
   DeleteStopOrder(g_stopOrderExit_num)                   -- удалить стоп-ордер
 
   while isRun do
      sleep(5000) -- обрабатываем цикл с задержкой 5сек. 
   end
end
 
-- функция вызывается терминалом ТЕРМИНАЛОМ QUIK при остановке скрипта
function OnStop()
   myLog("Script Stoped") 
   f:close() -- Закрывает файл
   isRun = false
end
 
function SendStopOrder(stopPrice, quantity, operation, trans_id)
   local offset=50 -- отступ для гарантированного исполнения ордера по рынку (в кол-ве шагов цены)
   local price
   local direction
 
   if operation=="B" then
      price = stopPrice + g_price_step*offset 
      direction = "5" -- Направленность стоп-цены. «5» - больше или равно
   else 
      price = stopPrice - g_price_step*offset 
      direction = "4" -- Направленность стоп-цены. «4» - меньше или равно
   end
   --message("stopPrice"..stopPrice)
   --Пошлем стоп заявку
   local Transaction = {
                       ['ACTION'] = "NEW_STOP_ORDER", 
                       ['PRICE'] = tostring(price), 
                       ['EXPIRY_DATE'] = "TODAY",--"GTC", -- на учебном серве только стоп-заявки с истечением сегодня, потом поменять на GTC
                       ['STOPPRICE'] = tostring(stopPrice),
                       ['STOP_ORDER_KIND'] = "SIMPLE_STOP_ORDER",
                       ['TRANS_ID'] = removeZero(tostring(trans_id)),
                       ['CLASSCODE'] = CLASS_CODE,
                       ['SECCODE'] = SEC_CODE,
                       ['ACCOUNT'] = ACCOUNT,
                       ['CLIENT_CODE'] = CLIENT_CODE, -- Комментарий к транзакции, который будет виден в транзакциях, заявках и сделках 
                       ['TYPE'] = "L",
                       ['OPERATION'] = tostring(operation),
                       ['CONDITION'] = direction, -- Направленность стоп-цены. Возможные значения: «4» - меньше или равно, «5» – больше или равно
                       ['QUANTITY'] = tostring(math.abs(quantity))
                       }
   local res = sendTransaction(Transaction)
   if string.len(res) ~= 0 then
      message('Error: '..res, 3)
      myLog("SendStopOrder(): Error "..res)
   else
      myLog("SendStopOrder(): "..EntryOrExit(trans_id).."; trans_id="..trans_id)
   end
end
 
function DeleteStopOrder(stopOrder_num)
   local Transaction = {
                       ['ACTION'] = "KILL_STOP_ORDER", 
                       ['CLASSCODE'] = CLASS_CODE,
                       ['SECCODE'] = SEC_CODE,
                       ['ACCOUNT'] = ACCOUNT,
                       ['CLIENT_CODE'] = CLIENT_CODE,
                       ['TYPE'] = "L",
                       ['STOP_ORDER_KIND'] = "SIMPLE_STOP_ORDER",
                       ['TRANS_ID'] = g_transId_del_order, -- ID УДАЛЯЮЩЕЙ транзакции
                       ['STOP_ORDER_KEY'] = tostring(stopOrder_num)
                       }
 
   local res = sendTransaction(Transaction)
   if string.len(res) ~= 0 then
      message('Error: '..res, 3)
      myLog("DeleteStopOrder(): fail "..res)
   else
      myLog("DeleteStopOrder(): "..stopOrder_num.." success ")
   end 
end
-- создан/изменен/сработал стоп-ордер 
function OnStopOrder(stopOrder)
   -- Если не относится к роботу, выходит из функции
   if stopOrder.brokerref:find(CLIENT_CODE) == nil then return end
 
   local string state="_" -- состояние заявки
   --бит 0 (0x1) Заявка активна, иначе не активна
   if bit.band(stopOrder.flags,0x1)==0x1 then
      state="стоп-заявка создана"
      if EntryOrExit(stopOrder.trans_id) == "Entry" then
         g_stopOrderEntry_num = stopOrder.order_num 
      end
      if EntryOrExit(stopOrder.trans_id) == "Exit" then
         g_stopOrderExit_num = stopOrder.order_num
      end 
   end
   if bit.band(stopOrder.flags,0x2)==0x1 or stopOrder.flags==26 then
      state="стоп-заявка снята"
   end
   if bit.band(stopOrder.flags,0x2)==0x0 and bit.band(stopOrder.flags,0x1)==0x0 then
      state="стоп-ордер исполнен"
   end
   if bit.band(stopOrder.flags,0x400)==0x1 then
      state="стоп-заявка сработала, но была отвергнута торговой системой"
   end
   if bit.band(stopOrder.flags,0x800)==0x1 then
      state="стоп-заявка сработала, но не прошла контроль лимитов"
   end
   if state=="_" then
      state="Набор битовых флагов="..tostring(stopOrder.flags)
   end
   myLog("OnStopOrder(): sec_code="..stopOrder.sec_code.."; "..EntryOrExit(stopOrder.trans_id)..";\t"..state..
         "; condition_price="..stopOrder.condition_price.."; transID="..stopOrder.trans_id.."; order_num="..stopOrder.order_num ) 
end
------------------------- Сервисные функции--------------------
-- функция записывает в лог строчку с временем и датой 
function myLog(str)
   if f==nil then return end
 
   local current_time=os.time()--tonumber(timeformat(getInfoParam("SERVERTIME"))) -- помещене в переменную времени сервера в формате HHMMSS 
   if (current_time-g_previous_time)>1 then -- если текущая запись произошла позже 1 секунды, чем предыдущая
      f:write("\n") -- добавляем пустую строку для удобства чтения
   end
   g_previous_time = current_time 
 
   f:write(os.date().."; ".. str .. ";\n")
 
   if str:find("Script Stoped") ~= nil then 
      f:write("======================================================================================================================\n\n")
      f:write("======================================================================================================================\n")
   end
   f:flush() -- Сохраняет изменения в файле
end
-- удаление точки и нулей после нее
function removeZero(str)
   while (string.sub(str,-1) == "0" and str ~= "0") do
      str = string.sub(str,1,-2)
   end
   if (string.sub(str,-1) == ".") then 
      str = string.sub(str,1,-2)
   end 
   return str
end
-- Возвращает Entry или Exit в зависимости от trans_id
function EntryOrExit(trans_id)
   if isArrayContain(g_arrTransId_entry, trans_id) then 
      return "Entry"
   elseif isArrayContain(g_arrTransId_exit, trans_id) then 
      return "Exit"
   elseif trans_id==g_transId_del_order then
      return "DeleteOrder"
   elseif trans_id==g_transId_del_stopOrder then
      return "DeleteStopOrder"
   else
      return "NoId"
   end
end
 
function isArrayContain(array, value)
   if #array < 1 then return end
      for i=1, #array do
         if array[i]==value then
         return true
      end
   end
   return false
end