#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

-- Вводим свои параметры
Account    = "*******"    -- Торговый счет
Class_Fut  = "SPBFUT"     -- Класс фьючерса
Sec_Fut    = "SiU6"       -- Код фьючерса
Class_Opt  = "SPBOPT"     -- Класс опциона
 
Short_Call = "Si75000BG6" -- Код опциона Short_Call
Long_Call  = "Si74000BG6" -- Код опциона Long_Call
Long_Put   = "Si63000BS6" -- Код опциона Long_Put
Short_Put  = "Si62000BS6" -- Код опциона Short_Put
 
Num_Lots   = 3            -- Кол-во лот, объем = 1
Step_Fut   = 250          -- Профит опциона на Step_Fut
Year       = 366          -- Число дней в году
Commission = 5            -- Комиссия (биржа + брокер на "круг" по 1-му лоту)
 
-- Здесь не меняем
SC_Open    = 0  -- Открыть
SC_Num     = 0  -- Текущий номер заявки
SC_Lin     = 0  -- Исходный номер заявки
SC_Volume  = 0  -- Общий объем
SC_Price   = {} -- Цена сделки
SC_Close   = 0  -- Закрыть
SC_Num_Cl  = {} -- Текущий номер заявки
SC_Lin_Cl  = {} -- Исходный номер заявки
 
LC_Open    = 0  -- Открыть
LC_Num     = 0  -- Текущий номер заявки
LC_Lin     = 0  -- Исходный номер заявки
LC_Volume  = 0  -- Общий объем
LC_Price   = {} -- Цена сделки
 
LP_Open    = 0  -- Открыть
LP_Num     = 0  -- Текущий номер заявки
LP_Lin     = 0  -- Исходный номер заявки
LP_Volume  = 0  -- Общий объем
LP_Price   = {} -- Цена сделки
 
SP_Open    = 0  -- Открыть
SP_Num     = 0  -- Текущий номер заявки
SP_Lin     = 0  -- Исходный номер заявки
SP_Volume  = 0  -- Общий объем
SP_Price   = {} -- Цена сделки
SP_Close   = 0  -- Закрыть
SP_Num_Cl  = {} -- Текущий номер заявки
SP_Lin_Cl  = {} -- Исходный номер заявки
 
History    = 0  -- Заработанный профит
 
trans_id   = os.time() -- Текущие дата и время в секундах хорошо подходят для уникальных номеров транзакций
IsRun      = true -- Флаг поддержания работы скрипта
 
function OnInit() -- Функция вызывается терминалом QUIK перед вызовом функции main()
   local f = io.open(getScriptPath().."//Spread_1.txt","r+") -- Пытается открыть файл состояния в режиме "чтения/записи"
   if f ~= nil then -- Если файл существует, перебирает строки файла, считывает содержимое в соответствующие переменные
      local Count = 0 -- Счетчик строк
      for line in f:lines() do
         Count = Count + 1
         if     Count == 1                                          then Arr = Lines(line); SC_Open = Arr.e1; SC_Num = Arr.e2; SC_Lin = Arr.e3; SC_Volume = Arr.e4; SC_Close = Arr.e5
         elseif Count >  1              and Count <= 1 +   Num_Lots then Arr = Lines(line); SC_Price[Count - 1] = Arr.e1; SC_Num_Cl[Count - 1] = Arr.e2; SC_Lin_Cl[Count - 1] = Arr.e3
         elseif Count == 2 +   Num_Lots                             then Arr = Lines(line); LC_Open = Arr.e1; LC_Num = Arr.e2; LC_Lin = Arr.e3; LC_Volume = Arr.e4
         elseif Count >  2 +   Num_Lots and Count <= 2 + 2*Num_Lots then Arr = Lines(line); LC_Price[Count - 2 - Num_Lots] = Arr.e1
         elseif Count == 3 + 2*Num_Lots                             then Arr = Lines(line); LP_Open = Arr.e1; LP_Num = Arr.e2; LP_Lin = Arr.e3; LP_Volume = Arr.e4
         elseif Count >  3 + 2*Num_Lots and Count <= 3 + 3*Num_Lots then Arr = Lines(line); LP_Price[Count - 3 - 2*Num_Lots] = Arr.e1
         elseif Count == 4 + 3*Num_Lots                             then Arr = Lines(line); SP_Open = Arr.e1; SP_Num = Arr.e2; SP_Lin = Arr.e3; SP_Volume = Arr.e4; SP_Close = Arr.e5
         elseif Count >  4 + 3*Num_Lots and Count <= 4 + 4*Num_Lots then Arr = Lines(line); SP_Price[Count - 4 - 3*Num_Lots] = Arr.e1; SP_Num_Cl[Count - 4 - 3*Num_Lots] = Arr.e2; SP_Lin_Cl[Count - 4 - 3*Num_Lots] = Arr.e3
         elseif Count == 5 + 4*Num_Lots                             then History = tonumber(line)
         end
      end
      f:close() -- Закрывает файл
   else
      for i = 1, Num_Lots, 1 do
         SC_Price[i] = 0; SC_Num_Cl[i] = 0; SC_Lin_Cl[i] = 0; LC_Price[i] = 0; LP_Price[i] = 0; SP_Price[i] = 0; SP_Num_Cl[i] = 0; SP_Lin_Cl[i] = 0
      end
   end
   -- Создает таблицу
   t_id = AllocTable() -- Получает доступный id для создания
   -- Добавляет колонки
   AddColumn(t_id, 0, "Опцион", true, QTABLE_STRING_TYPE, 15)
   AddColumn(t_id, 1, "Теоретическая", true, QTABLE_INT_TYPE, 7)
   AddColumn(t_id, 2, "Объем", true, QTABLE_INT_TYPE, 4)
   AddColumn(t_id, 3, "Цена", true, QTABLE_INT_TYPE, 7)
   AddColumn(t_id, 4, "Профит", true, QTABLE_INT_TYPE, 9)
   AddColumn(t_id, 5, "Profit", true, QTABLE_INT_TYPE, 7)
   AddColumn(t_id, 6, "P/L", true, QTABLE_INT_TYPE, 10)
   t = CreateWindow(t_id) -- Создает таблицу
   SetWindowCaption(t_id, "Spread_1") -- Устанавливает заголовок
   SetWindowPos(t_id, 000, 501, 349, 128) -- Задает положение и размеры окна таблицы
   for i = 1, 5, 1 do InsertRow(t_id, i) end -- Добавляет строки
   -- Добавляет значения в ячейки
   SetCell(t_id, 1, 0, Short_Call); SetCell(t_id, 2, 0, Long_Call); SetCell(t_id, 3, 0, Long_Put); SetCell(t_id, 4, 0, Short_Put)
   SetCell(t_id, 5, 2, tostring(Num_Lots)); Gray(5, 2) -- Кол-во лот
   SetCell(t_id, 5, 5, tostring(Step_Fut)); Gray(5, 5) -- Профит опциона на Step_Fut
end
 
function main() -- Функция, реализующая основной поток выполнения в скрипте
   while IsRun do -- Цикл будет выполнятся, пока IsRun == true
      SC = Options(Short_Call); LC = Options(Long_Call); LP = Options(Long_Put); SP = Options(Short_Put) -- Считаем параметры
      SC_Pr = 0; LC_Pr = 0; LP_Pr = 0; SP_Pr = 0 -- Средняя цена позиции
      for i = 1, Num_Lots, 1 do SC_Pr = SC_Pr + SC_Price[i]; LC_Pr = LC_Pr + LC_Price[i]; LP_Pr = LP_Pr + LP_Price[i]; SP_Pr = SP_Pr + SP_Price[i] end
      if SC_Volume > 0 then SC_Pr = round(SC_Pr / SC_Volume, 2) end; if LC_Volume > 0 then LC_Pr = round(LC_Pr / LC_Volume, 2) end; if LP_Volume > 0 then LP_Pr = round(LP_Pr / LP_Volume, 2) end; if SP_Volume > 0 then SP_Pr = round(SP_Pr / SP_Volume, 2) end
 
      SetCell(t_id, 1, 1, tostring(SC.Exchang)); SC_Profit = SC_Volume * (SC_Pr - SC.Exchang); Position(1, -SC_Volume, SC_Pr, SC_Profit); if SC_Open == -1 then Gray(1, 0) end
      SetCell(t_id, 2, 1, tostring(LC.Exchang)); LC_Profit = LC_Volume * (LC.Exchang - LC_Pr); Position(2,  LC_Volume, LC_Pr, LC_Profit); if LC_Open == -1 then Gray(2, 0) end
      SetCell(t_id, 3, 1, tostring(LP.Exchang)); LP_Profit = LP_Volume * (LP.Exchang - LP_Pr); Position(3,  LP_Volume, LP_Pr, LP_Profit); if LP_Open == -1 then Gray(3, 0) end
      SetCell(t_id, 4, 1, tostring(SP.Exchang)); SP_Profit = SP_Volume * (SP_Pr - SP.Exchang); Position(4, -SP_Volume, SP_Pr, SP_Profit); if SP_Open == -1 then Gray(4, 0) end
      SetCell(t_id, 5, 3, tostring(History)); Str(5, 4, SC_Profit + LC_Profit + LP_Profit + SP_Profit)
      SetCell(t_id, 5, 0, tostring(tonumber(getParamEx(Class_Opt, Long_Call, "days_to_mat_date").param_value)).." / "..os.date("%X")) -- Число дней до погашения, время компьютера
      Str(5, 1, - SC_Volume * SC.Theta_C + LC_Volume * LC.Theta_C + LP_Volume * LP.Theta_P - SP_Volume * SP.Theta_P) -- Тетта
      SetCell(t_id, 1, 5, tostring(SC.Profit_C)); SetCell(t_id, 2, 5, tostring(LC.Profit_C)); SetCell(t_id, 3, 5, tostring(LP.Profit_P)); SetCell(t_id, 4, 5, tostring(SP.Profit_P)) -- Профит опциона на Step_Fut
 
      Le_C = SC_Volume * SC_Pr - LC_Volume * LC_Pr; Str(2, 6, Le_C) -- Убыток спрэда Call
      Le_P = SP_Volume * SP_Pr - LP_Volume * LP_Pr; Str(4, 6, Le_P) -- Убыток спрэда Put
      Le_CP = Le_C + Le_P; Str(3, 6, Le_CP) -- Убыток спрэда Call + Put
      Step_Strike = tonumber(string.sub(Short_Call, 3, #Short_Call - 3)) - tonumber(string.sub(Long_Call, 3, #Long_Call - 3))
      if SC_Volume > 0 and SC_Volume == LC_Volume then Pr_C = (SC_Volume + LC_Volume) / 2 * Step_Strike + Le_CP; Str(1, 6, Pr_C) -- Профит спрэда Call
      elseif SC_Volume < LC_Volume then SetCell(t_id, 1, 6, "~"); Green(1, 6)
      else SetCell(t_id, 1, 6, ""); White(1, 6) end
      Step_Strike = tonumber(string.sub(Long_Put, 3, #Long_Put - 3)) - tonumber(string.sub(Short_Put, 3, #Short_Put - 3))
      if SP_Volume > 0 and SP_Volume == LP_Volume then Pr_P = (SP_Volume + LP_Volume) / 2 * Step_Strike + Le_CP; Str(5, 6, Pr_P) -- Профит спрэда Put
      elseif SP_Volume < LP_Volume then SetCell(t_id, 5, 6, "~"); Green(5, 6)
      else SetCell(t_id, 5, 6, ""); White(5, 6) end
 
      if tonumber(getParamEx(Class_Fut, Sec_Fut, "status").param_value) == 1 then -- Торговля разрешена или нет
         Green(5, 0)
         ---------------------------------------------------------------------------------
         -- Открыть Long_Call
         if LC_Open == 0 and LC_Num == 0 then -- Заявки Long_Call нет
            iLC_Pr = 0; for i = Num_Lots, 1, -1 do if LC_Price[i] == 0 then iLC_Pr = i end; end
            if iLC_Pr == 1 or (iLC_Pr > 1 and LC.Exchang < LC_Price[iLC_Pr - 1] - LC.Profit_C - Commission) then
               Transaction("Покупка", Long_Call, LC.Exchang)
            end
         end
         -- Снять Long_Call
         if LC_Open > 0 and LC_Num > 0 then -- Заявка Long_Call есть
            if LC.Exchang ~= LC_Open then
               Kill(Long_Call, LC_Num)
            end
         end
         ---------------------------------
         -- Открыть, снять Short_Call
         for i = 1, Num_Lots, 1 do
            if SC_Price[i] == 0 and LC_Price[i] > 0 then -- Сделки Short_Call нет
               if SC.Exchang > LC_Price[i] + Commission or (LC.Exchang > LC_Price[i] + LC.Profit_C + Commission and SC.Exchang > SC.Profit_C + Commission) then
                  if SC_Open == 0 and SC_Num == 0 then -- Заявки Short_Call нет
                     Transaction("Продажа", Short_Call, SC.Exchang) -- Открыть Short_Call
                  end
                  if SC_Open > 0 and SC_Num > 0 then -- Заявка Short_Call есть
                     if SC.Exchang ~= SC_Open then
                        Kill(Short_Call, SC_Num) -- Снять Short_Call
                     end
                  end
               end
            end
         end
         -- Закрыть Short_Call
         for i = 1, Num_Lots, 1 do
            if SC_Price[i] > 0 and SC_Price[i] - LC_Price[i] < 0 then -- Сделка Short_Call есть и убыток спрэда Call < 0
               if SC_Close == 0 and SC_Num_Cl[i] == 0 then -- Заявки Short_Call нет
                  Transaction("Покупка", Short_Call, SC_Price[i] - SC.Profit_C)
               end
            end
         end
         ---------------------------------------------------------------------------------
         -- Открыть Long_Put
         if LP_Open == 0 and LP_Num == 0 then -- Заявки Long_Put нет
            iLP_Pr = 0; for i = Num_Lots, 1, -1 do if LP_Price[i] == 0 then iLP_Pr = i end; end
            if iLP_Pr == 1 or (iLP_Pr > 1 and LP.Exchang < LP_Price[iLP_Pr - 1] - LP.Profit_P - Commission) then
               Transaction("Покупка", Long_Put, LP.Exchang)
            end
         end
         -- Снять Long_Put
         if LP_Open > 0 and LP_Num > 0 then -- Заявка Long_Put есть
            if LP.Exchang ~= LP_Open then
               Kill(Long_Put, LP_Num)
            end
         end
         --------------------------------
         -- Открыть, снять Short_Put
         for i = 1, Num_Lots, 1 do
            if SP_Price[i] == 0 and LP_Price[i] > 0 then -- Сделки Short_Put нет
               if SP.Exchang > LP_Price[i] + Commission or (LP.Exchang > LP_Price[i] + LP.Profit_P + Commission and SP.Exchang > SP.Profit_P + Commission) then
                  if SP_Open == 0 and SP_Num == 0 then -- Заявки Short_Put нет
                     Transaction("Продажа", Short_Put, SP.Exchang) -- Открыть Short_Put
                  end
                  if SP_Open > 0 and SP_Num > 0 then -- Заявка Short_Put есть
                     if SP.Exchang ~= SP_Open then
                        Kill(Short_Put, SP_Num) -- Снять Short_Put
                     end
                  end
               end
            end
         end
         -- Закрыть Short_Put
         for i = 1, Num_Lots, 1 do
            if SP_Price[i] > 0 and SP_Price[i] - LP_Price[i] < 0 then -- Сделка Short_Put есть и убыток спрэда Put < 0
               if SP_Close == 0 and SP_Num_Cl[i] == 0 then -- Заявки Short_Put нет
                  Transaction("Покупка", Short_Put, SP_Price[i] - SP.Profit_P)
               end
            end
         end
         ---------------------------------------------------------------------------------
      else
         Red(5, 0)
      end
      sleep(100)
   end
end
 
function OnStop() -- Функция вызывается терминалом QUIK при остановке скрипта из диалога управления
   SaveCurrentState()
   IsRun = false
end
 
function SaveCurrentState() -- Функция сохраняет текущее состояние в файл
   local f = io.open(getScriptPath().."//Spread_1.txt","w") -- Создает файл в режиме "записи"
   -- Записывает в файл текущее состояние
   f:write(SC_Open..";"..SC_Num..";"..SC_Lin..";"..SC_Volume..";"..SC_Close.."\n")
   for i = 1, Num_Lots, 1 do f:write(SC_Price[i]..";"..SC_Num_Cl[i]..";"..SC_Lin_Cl[i].."\n") end
   f:write(LC_Open..";"..LC_Num..";"..LC_Lin..";"..LC_Volume.."\n")
   for i = 1, Num_Lots, 1 do f:write(LC_Price[i].."\n") end
   f:write(LP_Open..";"..LP_Num..";"..LP_Lin..";"..LP_Volume.."\n")
   for i = 1, Num_Lots, 1 do f:write(LP_Price[i].."\n") end
   f:write(SP_Open..";"..SP_Num..";"..SP_Lin..";"..SP_Volume..";"..SP_Close.."\n")
   for i = 1, Num_Lots, 1 do f:write(SP_Price[i]..";"..SP_Num_Cl[i]..";"..SP_Lin_Cl[i].."\n") end
   f:write(History.."\n")
   f:flush() -- Сохраняет изменения в файле
   f:close() -- Закрывает файл
end
function Lines(line) -- Функция читает строку в файле состояния
   local i = 0 -- Счетчик элементов строки
   for str in line:gmatch("[^;^\n]+") do
      i = i + 1
      if     i == 1 then e1 = tonumber(str)
      elseif i == 2 then e2 = tonumber(str)
      elseif i == 3 then e3 = tonumber(str)
      elseif i == 4 then e4 = tonumber(str)
      elseif i == 5 then e5 = tonumber(str)
      end
   end
   return {["e1"] = e1,
           ["e2"] = e2,
           ["e3"] = e3,
           ["e4"] = e4,
           ["e5"] = e5}
end
 
function Str(line, column, profit) -- Функция выводит и окрашивает переданный профит в таблицу
   SetCell(t_id, line, column, tostring(profit)) -- Выводит значение в таблицу
   if profit == 0 then White(line, column) elseif profit > 0 then Green(line, column) else Red(line, column) end -- Окрашивает ячейку в зависимости от значения профита
end
function Position(line, volume, price, profit) -- Функция выводит и окрашивает переданный volume, price, profit
   if volume ~= 0 then
      SetCell(t_id, line, 2, tostring(volume)); SetCell(t_id, line, 3, tostring(price)); SetCell(t_id, line, 4, tostring(profit))
      if profit == 0 then White(line, 0); White(line, 1); White(line, 2); White(line, 3); White(line, 4)
      elseif profit > 0 then Green(line, 0); Green(line, 1); Green(line, 2); Green(line, 3); Green(line, 4)
      else Red(line, 0); Red(line, 1); Red(line, 2); Red(line, 3); Red(line, 4) end
   else White(line, 0); White(line, 1); SetCell(t_id, line, 2, ""); White(line, 2); SetCell(t_id, line, 3, ""); White(line, 3); SetCell(t_id, line, 4, ""); White(line, 4) end
end
 
-- Функции по раскраске ячеек таблицы
function White(line, column) -- Белый
   SetColor(t_id, line, column, RGB(255,255,255), RGB(0,0,0), RGB(255,255,255), RGB(0,0,0))
end
function Green(line, column) -- Зеленый
   SetColor(t_id, line, column, RGB(165,227,128), RGB(0,0,0), RGB(165,227,128), RGB(0,0,0))
end
function Red(line, column) -- Красный
   SetColor(t_id, line, column, RGB(255,168,164), RGB(0,0,0), RGB(255,168,164), RGB(0,0,0))
end
function Gray(line, column) -- Серый
   SetColor(t_id, line, column, RGB(208,208,208), RGB(0,0,0), RGB(208,208,208), RGB(0,0,0))
end
 
function Options(sec) -- Функция считает параметры опциона
   local P = tonumber(getParamEx(Class_Fut, Sec_Fut, "settleprice").param_value) -- Текущая цена фьючерса
   local S = tonumber(string.sub(sec, 3, #sec - 3)) -- Страйк опциона
   local V = tonumber(getParamEx(Class_Opt, sec, "volatility").param_value) / 100 -- Волатильность опциона в долях
   local D = tonumber(getParamEx(Class_Opt, sec, "days_to_mat_date").param_value) / Year -- Число дней до погашения в долях года
   local d1 = (math.log(P / S) + V * V * D / 2) / (V * math.sqrt(D))
   local d2 = d1 - V * math.sqrt(D)
   local Exchang = tonumber(getParamEx(Class_Opt, sec, "theorprice").param_value) -- Теоретическая цена биржи
   local Theta = (-P * V * math.exp(-D) * pN(d1)) / (2 * math.sqrt(D))
   local Theta_C = round((Theta - (S * math.exp(-D) * N(d2)) + P * math.exp(-D) * N(d1)) / Year, 0) -- Тетта Call
   local Theta_P = round((Theta + (S * math.exp(-D) * N(-d2)) - P * math.exp(-D) * N(-d1)) / Year, 0) -- Тетта Put
   local Delta_C = round(math.exp(-D) * N(d1), 2) -- Дельта Call
   local Profit_C = round(Step_Fut * Delta_C, 0) -- Профит для Call
   local Delta_P = -round(-math.exp(-D) * N(-d1), 2) -- Дельта Put
   local Profit_P = round(Step_Fut * Delta_P, 0) -- Профит для Put
   return {["Exchang"] = Exchang,
           ["Theta_C"] = Theta_C,
           ["Theta_P"] = Theta_P,
           ["Profit_C"] = Profit_C,
           ["Profit_P"] = Profit_P}
end
function N(x) -- Функция нормального среднего
   if x > 10 then return 1
   elseif x < -10 then return 0
   else
      local t = 1 / (1 + 0.2316419 * math.abs(x))
      local p = 0.3989423 * math.exp(-0.5 * x * x) * t * ((((1.330274 * t - 1.821256) * t + 1.781478) * t - 0.3565638) * t + 0.3193815)
      if x > 0 then p = 1 - p end
      return p
   end
end
function pN(x) -- Функция, производная от нормального среднего
   return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)
end
function round(num, idp) -- Функция округляет до указанного количества знаков
   local mult = 10^idp
   return math.floor(num * mult + 0.5) / mult
end
 
function Transaction(bs, sec, open) -- Функция отправляет транзакцию
   trans_id = trans_id + 1 -- Получает ID для транзакции
   if sec == Short_Call then if bs == "Продажа" then SC_Open = trans_id else SC_Close = trans_id end; end -- Short_Call
   if sec == Long_Call  then LC_Open = trans_id end -- Long_Call
   if sec == Long_Put   then LP_Open = trans_id end -- Long_Put
   if sec == Short_Put  then if bs == "Продажа" then SP_Open = trans_id else SP_Close = trans_id end; end -- Short_Put
   local Transaction           = { -- Заполняет структуру для отправки транзакции
      ["TRANS_ID"]             = tostring(trans_id);
      ["CLASSCODE"]            = Class_Opt;
      ["ACTION"]               = "Ввод заявки";
      ["Торговый счет"]        = Account;
      ["К/П"]                  = bs;
      ["Тип"]                  = "Лимитированная";
      ["Класс"]                = Class_Opt;
      ["Инструмент"]           = sec;
      ["Цена"]                 = tostring(open);
      ["Количество"]           = "1";
      ["Условие исполнения"]   = "Поставить в очередь";
      ["Комментарий"]          = "";
      ["Проверять лимит цены"] = "Да";
      ["Переносить заявку"]    = "Да";
      ["Дата экспирации"]      = tostring(tonumber(getParamEx(Class_Opt, sec, "mat_date").param_value));}
   local res = sendTransaction(Transaction) -- Отправляет транзакцию
   if res ~= "" then message("Ошибка отправки транзакции: "..res) end
end
 
function Kill(sec, num) -- Функция снимает заявку по номеру
   trans_id = trans_id + 1 -- Получает ID для транзакции
   if sec == Short_Call then SC_Open = 0 end -- Short_Call
   if sec == Long_Call  then LC_Open = 0 end -- Long_Call
   if sec == Long_Put   then LP_Open = 0 end -- Long_Put
   if sec == Short_Put  then SP_Open = 0 end -- Short_Put
   local Transaction = { -- Заполняет структуру для отправки транзакции
      ["TRANS_ID"]   = tostring(trans_id);
      ["CLASSCODE"]  = Class_Opt;
      ["SECCODE"]    = sec;
      ["ACTION"]     = "KILL_ORDER";
      ["ORDER_KEY"]  = tostring(num);}
   local res = sendTransaction(Transaction) -- Отправляет транзакцию
end
 
function OnTransReply(trans_reply) -- Функция вызывается терминалом, когда с сервера приходит новая информация о транзакциях
   -- Выставляем заявку Long_Call
   if LC_Open > 0 and LC_Num == 0 and LC_Open == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Long_Call
      if trans_reply.status == 3 then -- Транзакция Long_Call выполнена
         LC_Open = trans_reply.price
         LC_Num = trans_reply.order_num
         LC_Lin = trans_reply.order_num
      elseif trans_reply.status == 4 then -- Нет денег
         LC_Open = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         LC_Open = 0
      end
   end
   -- Снимаем заявку Long_Call
   if LC_Open == 0 and LC_Num > 0 and LC_Num == trans_reply.order_num then -- Если пришла информация по нашей транзакции Long_Call
      if trans_reply.status == 3 then -- Транзакция Long_Call выполнена
         LC_Num = 0
         LC_Lin = 0
      elseif trans_reply.status > 3 then -- Произошла ошибка
         LC_Open = trans_reply.price
      end
   end
   -- Выставляем заявку Short_Call
   if SC_Open > 0 and SC_Num == 0 and SC_Open == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Short_Call
      if trans_reply.status == 3 then -- Транзакция Short_Call выполнена
         SC_Open = trans_reply.price
         SC_Num = trans_reply.order_num
         SC_Lin = trans_reply.order_num
      elseif trans_reply.status == 4 then -- Нет денег
         SC_Open = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         SC_Open = 0
      end
   end
   -- Снимаем заявку Short_Call
   if SC_Open == 0 and SC_Num > 0 and SC_Num == trans_reply.order_num then -- Если пришла информация по нашей транзакции Short_Call
      if trans_reply.status == 3 then -- Транзакция Short_Call выполнена
         SC_Num = 0
         SC_Lin = 0
      elseif trans_reply.status > 3 then -- Произошла ошибка
         SC_Open = trans_reply.price
      end
   end
   -- Выставляем заявку закрыть Short_Call
   if SC_Close > 0 and SC_Close == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Short_Call
      if trans_reply.status == 3 then -- Транзакция Short_Call выполнена
         for i = 1, Num_Lots, 1 do
            if SC_Price[i] > 0 and SC_Num_Cl[i] == 0 then
               SC_Num_Cl[i] = trans_reply.order_num
               SC_Lin_Cl[i] = trans_reply.order_num
               SC_Close = 0
            end
         end
      elseif trans_reply.status == 4 then -- Нет денег
         SC_Close = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         SC_Close = 0
      end
   end
   ---------------------------------------------------------------------------------
   -- Выставляем заявку Long_Put
   if LP_Open > 0 and LP_Num == 0 and LP_Open == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Long_Put
      if trans_reply.status == 3 then -- Транзакция Long_Put выполнена
         LP_Open = trans_reply.price
         LP_Num = trans_reply.order_num
         LP_Lin = trans_reply.order_num
      elseif trans_reply.status == 4 then -- Нет денег
         LP_Open = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         LP_Open = 0
      end
   end
   -- Снимаем заявку Long_Put
   if LP_Open == 0 and LP_Num > 0 and LP_Num == trans_reply.order_num then -- Если пришла информация по нашей транзакции Long_Put
      if trans_reply.status == 3 then -- Транзакция Long_Put выполнена
         LP_Num = 0
         LP_Lin = 0
      elseif trans_reply.status > 3 then -- Произошла ошибка
         LP_Open = trans_reply.price
      end
   end
   -- Выставляем заявку Short_Put
   if SP_Open > 0 and SP_Num == 0 and SP_Open == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Short_Put
      if trans_reply.status == 3 then -- Транзакция Short_Put выполнена
         SP_Open = trans_reply.price
         SP_Num = trans_reply.order_num
         SP_Lin = trans_reply.order_num
      elseif trans_reply.status == 4 then -- Нет денег
         SP_Open = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         SP_Open = 0
      end
   end
   -- Снимаем заявку Short_Put
   if SP_Open == 0 and SP_Num > 0 and SP_Num == trans_reply.order_num then -- Если пришла информация по нашей транзакции Short_Put
      if trans_reply.status == 3 then -- Транзакция Short_Put выполнена
         SP_Num = 0
         SP_Lin = 0
      elseif trans_reply.status > 3 then -- Произошла ошибка
         SP_Open = trans_reply.price
      end
   end
   -- Выставляем заявку закрыть Short_Put
   if SP_Close > 0 and SP_Close == trans_reply.trans_id then -- Если пришла информация по нашей транзакции Short_Put
      if trans_reply.status == 3 then -- Транзакция Short_Put выполнена
         for i = 1, Num_Lots, 1 do
            if SP_Price[i] > 0 and SP_Num_Cl[i] == 0 then
               SP_Num_Cl[i] = trans_reply.order_num
               SP_Lin_Cl[i] = trans_reply.order_num
               SP_Close = 0
            end
         end
      elseif trans_reply.status == 4 then -- Нет денег
         SP_Close = -1
      elseif trans_reply.status > 4 then -- Произошла ошибка
         SP_Close = 0
      end
   end
   SaveCurrentState()
end
 
function OnOrder(order) -- Функция вызывается терминалом QUIK при получении новой заявки или при изменении параметров существующей заявки
   if LC_Lin > 0 and LC_Lin == order.linkedorder then -- Новый номер Long_Call
      LC_Num = order.order_num
   end
   if SC_Lin > 0 and SC_Lin == order.linkedorder then -- Новый номер Short_Call
      SC_Num = order.order_num
   end
   for i = 1, Num_Lots, 1 do
      if SC_Lin_Cl[i] > 0 and SC_Lin_Cl[i] == order.linkedorder then -- Новый номер закрыть Short_Call
         SC_Num_Cl[i] = order.order_num
      end
   end
   ---------------------------------------------------------------------------------
   if LP_Lin > 0 and LP_Lin == order.linkedorder then -- Новый номер Long_Put
      LP_Num = order.order_num
   end
   if SP_Lin > 0 and SP_Lin == order.linkedorder then -- Новый номер Short_Put
      SP_Num = order.order_num
   end
   for i = 1, Num_Lots, 1 do
      if SP_Lin_Cl[i] > 0 and SP_Lin_Cl[i] == order.linkedorder then -- Новый номер закрыть Short_Put
         SP_Num_Cl[i] = order.order_num
      end
   end
   SaveCurrentState()
end
 
function OnTrade(trade) -- Функция вызывается терминалом QUIK при получении сделки
   if LC_Num == trade.order_num then -- Сделка Long_Call
      LC_Open = 0
      LC_Num = 0
      LC_Lin = 0
      LC_Volume = LC_Volume + trade.qty
      for i = Num_Lots, 1, -1 do if LC_Price[i] == 0 then iLC_Pr = i end; end
      LC_Price[iLC_Pr] = trade.price + Commission
   end
   if SC_Num == trade.order_num then -- Сделка Short_Call
      SC_Open = 0
      SC_Num = 0
      SC_Lin = 0
      SC_Volume = SC_Volume + trade.qty
      for i = Num_Lots, 1, -1 do if SC_Price[i] == 0 then iSC_Pr = i end; end
      SC_Price[iSC_Pr] = trade.price - Commission
   end
   for i = 1, Num_Lots, 1 do -- Сделка закрыть Short_Call
      if SC_Num_Cl[i] == trade.order_num then
         LC_Price[i] = LC_Price[i] - SC_Price[i] + trade.price
         History = History + SC_Price[i] - trade.price
         SC_Volume = SC_Volume - trade.qty
         SC_Price[i] = 0
         SC_Num_Cl[i] = 0
         SC_Lin_Cl[i] = 0
      end
   end
   ---------------------------------------------------------------------------------
   if LP_Num == trade.order_num then -- Сделка Long_Put
      LP_Open = 0
      LP_Num = 0
      LP_Lin = 0
      LP_Volume = LP_Volume + trade.qty
      for i = Num_Lots, 1, -1 do if LP_Price[i] == 0 then iLP_Pr = i end; end
      LP_Price[iLP_Pr] = trade.price + Commission
   end
   if SP_Num == trade.order_num then -- Сделка Short_Put
      SP_Open = 0
      SP_Num = 0
      SP_Lin = 0
      SP_Volume = SP_Volume + trade.qty
      for i = Num_Lots, 1, -1 do if SP_Price[i] == 0 then iSP_Pr = i end; end
      SP_Price[iSP_Pr] = trade.price - Commission
   end
   for i = 1, Num_Lots, 1 do -- Сделка закрыть Short_Put
      if SP_Num_Cl[i] == trade.order_num then
         LP_Price[i] = LP_Price[i] - SP_Price[i] + trade.price
         History = History + SP_Price[i] - trade.price
         SP_Volume = SP_Volume - trade.qty
         SP_Price[i] = 0
         SP_Num_Cl[i] = 0
         SP_Lin_Cl[i] = 0
      end
   end
   SaveCurrentState()
end