--C:/QUIK/LuaIndicators/extr.lua
dofile(getWorkingFolder() .. "\\LuaIndicators\\Include\\myExtr.lua")
Settings = {}
Settings.Name = "*extr"
Settings.nDepth = 3000 --[[для определения стартового бара]]
Settings.nMinHL = 0 --[[минимальное движение цены для определения экстремума]]
Settings.line =
{
 {
 Name = "TRIANGLE_UP",
 Type = TYPE_TRIANGLE_UP,
 Color = RGB(255, 0, 0),
 Width = 4
 },
 {
 Name = "TRIANGLE_DOWN",
 Type = TYPE_TRIANGLE_DOWN,
 Color = RGB(0, 255, 0),
 Width = 4
 }
}
 
function Init()
 extr = myExtr()
 return 2
end
 
local oi, min_hl
function OnCalculate(index)
 
 if index == 1 then
 min_hl = tonumber(Settings.nMinHL)
 
 if min_hl and min_hl <= 0 then min_hl = nil end
 if not min_hl then return message("Индикатору extr нужен параметр nMinHL > 0",3) end
 
 local depth = tonumber(Settings.nDepth) or Size()
 local s = Size() - depth
 oi = s < 1 and 1 or s
 
 extr(oi, min_hl, index)
 end
 --[[считает только что закрывшийся бар, в текущем активном не считает]]
 if not min_hl or index <= oi then return end
 
 extr(oi, min_hl, index)
 oi = index
end

--C:/QUIK/LuaIndicators/Include/myExtr.lua
function myExtr()
   local HH, LL, mH, mL, imH, imL
   local function SetL(oH, oL, oi, min_hl)
      if oH > mH then
         mH, imH = oH, oi
         if not LL then
            if oH - mL >= min_hl then
               LL = mL
               SetValue(imL, 1, LL)
               mL, imL = oL, oi
               HH = nil
            end
         else
            mL, imL = oL, oi
         end
         if HH and oH >= HH then HH = nil end
      end
   end
   local function SetH(oH, oL, oi, min_hl)
      if oL < mL then
         mL, imL = oL, oi
         if not HH then
            if mH - oL >= min_hl then
               HH = mH
               SetValue(imH, 2, HH)
               mH, imH = oH, oi
               LL = nil
            end
         else
            mH, imH = oH, oi
         end
         if LL and oL <= LL then LL = nil end
      end
   end
   return function (oi, min_hl, i)
      if i <= oi then
         mH, mL = H(oi), L(oi)
         imH, imL = oi, oi
         HH, LL = nil, nil
         return
      end
 
      local oH, oL = H(oi), L(oi)
      if imL < imH then
         SetL(oH, oL, oi, min_hl)
         SetH(oH, oL, oi, min_hl)
      else
         SetH(oH, oL, oi, min_hl)
         SetL(oH, oL, oi, min_hl)
      end
   end
end

 
#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");