Порядок отслеживания процесса выполнения транзакций

Multimap = {};
Multimap.__index = Multimap;

function Multimap.Create()
   local self = {};
   setmetatable(self, Multimap);
   return self;
end

function Multimap:Ins ert(key, value)
   local list = self[key];
   if (list == nil) then
      list = {};
      self[key] = list;
   end
   table.ins ert(list, value);
end

function Multimap:Remove(key, value)
   local list = self[key];
   assert(list ~= nil, "key not found");
   for k,v in ipairs(list) do
      if (v == value) then
         table.remove(list, k);
         if (#list == 0) then
            self[key] = nil;
         end
         return;
      end
   end
   assert(false, "val ue not found");
end





-- Transaction class

Transaction = {};
Transaction.__index = Transaction;

ST_PENDING_NEW = 1;
ST_REJECTED = 2;
ST_NEW = 3;
ST_FILLED = 4;

function Transaction.CreateLimit(request)
   local self = {};
   setmetatable(self, Transaction);
   
   self.request = request;
   local os_time = os.time();
   self.id = self:GenerateId(os_time);
   self.time = os_time;
   self:ModifyHeader();
   
   self.status = ST_PENDING_NEW;
   Robot.transid_map[self.id] = self;
   
   self.volume = tonumber(self.request.QUANTITY);
   self.pending_volume = self.volume;
   self.trades = {};
   
   local ret = sendTransaction(self.request);
   if (ret ~= '') then
      Robot.transid_map[self.id] = nil;
      self:OnStatusChanged(ST_REJECTED);
   else
      Robot.time_map:Insert(os_time, self);
   end
end

function Transaction:ModifyHeader(os_time)
   assert(self.request.TRANS_ID == nil, "We use trans_id internally.");
   self.request.TRANS_ID = string.format("%d", self.id);
   self.request.CLIENT_CODE = string.format("%s//L%04d", self.request.CLIENT_CODE, Robot.id);
end

Transaction.max_trans_id = 0;
function Transaction:GenerateId(os_time)
   Transaction.max_trans_id = Transaction.max_trans_id + 1;
   local id = Robot.id * 10000 + os_time % (60*60*24*30 * 300) + Transaction.max_trans_id;
   assert(Robot.transid_map[id] == nil);
   return id;
end

function Transaction:UpdateTiming()
   Robot.time_map:Remove(self.time, self);
   local os_time = os.time();
   self.time = os_time;
   Robot.time_map:Insert(os_time, self);
end

function Transaction:InternalDelete()
   Robot.time_map:Remove(self.time, self);
   Robot.transid_map[self.id] = nil;
   if (self.orderid ~= nil) then
      Robot.orderid_map[self.orderid] = nil;
   end
end

-- consider we matched transaction by id and client_code already
function Transaction:OnTransReply(trans_reply)
   if (self.flag_ontransreply) then
      -- ignore all callback duplicates
      return;
   end
   assert(trans_reply.class_code == self.request.CLASSCODE and trans_reply.sec_code == self.request.SECCODE, "classcode or seccode mismatch");

   self.flag_ontransreply = true;
   -- только status == 3 говорит об успешном выставлении заявки
   if (trans_reply.status == 3) then
      self:OnStatusChanged(ST_NEW);
      if (self.orderid == nil) then
         self.orderid = trans_reply.order_num;
         Robot.orderid_map[self.orderid] = self;
      else
         assert(self.orderid == trans_reply.order_num);
      end
      self:UpdateTiming();
   else
      self:OnStatusChanged(ST_REJECTED);
      self:InternalDelete();
   end
end

-- consider we matched transaction by id and client_code already
function Transaction:OnOrder(order)
   if (self.flag_onorder) then
      -- ignore all callback duplicates
      return;
   end
   assert(order.class_code == self.request.CLASSCODE and order.sec_code == self.request.SECCODE, "classcode or seccode mismatch");
   
   self.flag_onorder = true;
   if (self.orderid == nil) then
      self.orderid = trans_reply.order_num;
      Robot.orderid_map[self.orderid] = self;
   else
      assert(self.orderid == order.order_num);
   end

   local test = bittest(order.flags, 3);
   if (test == 0) then
      -- если бит 0 и 1 не установлены -- заявка выполнена
      self:OnStatusChanged(ST_FILLED);
      self:InternalDelete();
   else
      local sell = bittest(order.flags, 4) ~= 0;
      assert((sell == (self.request.OPERATION == "S")) and (not sell == (self.request.OPERATION == "B")));
      if (test == 2) then
         self:OnStatusChanged(ST_REJECTED);
         self:InternalDelete();
      else
         self:UpdateTiming();
      end
   end
end

-- consider we matched transaction by id and client_code already
function Transaction:OnTrade(order)
   if (self.trades[order.trade_num]) then
      -- ignore all callback duplicates
      return;
   end
   assert(order.class_code == self.request.CLASSCODE and order.sec_code == self.request.SECCODE, "classcode or seccode mismatch");
   
   self.trades[order.trade_num] = true;
   print(string.format("OnTrade: %s:%s qty %g price %g settle %s:%s:%d", 
      order.class_code, order.sec_code, order.qty, order.price, order.settle_currency, order.settlecode, order.settle_date));
   self.pending_volume = self.pending_volume - order.qty;
   assert(self.pending_volume >= 0);
   self:UpdateTiming();
end

function Transaction:OnStatusChanged(new_status)
   message("Transaction changed status fr om "..self.status.." to "..new_status, 1);
   self.status = new_status;
end

function Transaction:OnTimeout()
   if (self.pending_volume == 0) then
      self:InternalDelete();
   else
      self:UpdateTiming();
   end
end





-- Robot class

Robot = {};
Robot.__index = {};

function Robot.Create(id, timeout)
   assert(id ~= nil, "id is required");
   timeout = timeout or 5;
   
   assert(Robot.id == nil, "Robot is singleton class");
   Robot.id = id;
   Robot.timeout = timeout;
   Robot.time_map = Multimap.Create();
   Robot.transid_map = {};
   Robot.orderid_map = {};
   Robot.trade_queue = Multimap.Create();
   return Robot;
end

function Robot:CheckTimeouts()
   local limit_time = os.time() - Robot.timeout;
   for timestamp,list in pairs(Robot.time_map) do
      if (timestamp <= limit_time) then
         for _,trans in ipairs(list) do
            trans:OnTimeout();
         end
      end
   end

   -- check not matched yet transactions
   for orderid,list in pairs(self.trade_queue) do
      local trans = self.orderid_map[orderid];
      if (trans ~= nil) then
         self.trade_queue[orderid] = nil;
         for _,v in ipairs(list) do
            trans:OnTrade(v);
         end
      end
   end
end

function Robot:CheckTradeQueueFor(trans)
   local list = self.trade_queue[trans.orderid];
   if (list ~= nil) then
      self.trade_queue[trans.orderid] = nil;
      for _,v in pairs(list) do
         trans:OnTrade(v);
      end
   end
end

function Robot:CheckComment(comment)
   return tonumber(string.match(comment, ".+//L(%d%d%d%d)$")) == self.id;
end

function Robot:SearchTransaction(transid, comment)
   if comment and not self:CheckComment(comment) then
      return nil;
   end
   if transid then
      return self.transid_map[transid];
   end
   return nil;
end

function OnTransReply(trans_reply)
   local trans = Robot:SearchTransaction(trans_reply.trans_id, nil, trans_reply.brokerref);
   if (trans ~= nil) then
      trans:OnTransReply(trans_reply);
   end
end

function OnTrade(order)
   if Robot:CheckComment(order.brokerref) then
      local trans = Robot.orderid_map[order.order_num];
      if (trans ~= nil) then
         Robot:CheckTradeQueueFor(trans);
         trans:OnTrade(order);
      else
         Robot.trade_queue:Insert(order.order_num, order);
      end
   end
end

function OnOrder(order)
   local trans = Robot:SearchTransaction(order.trans_id, order.brokerref);
   if (trans ~= nil) then
      trans:OnOrder(order);
   end
end


running = true;
function OnStop()
   running = false;
end

function main()
   print("Main function execution");
   local robot = Robot.Create(4242);
   
   Transaction.CreateLim it {
      ACCOUNT = "L01-00000F00",
      CLIENT_CODE = "51448",
      ACTION = "NEW_ORDER",
      CLASSCODE = "TQBR", SECCODE = "MTSS",
      OPERATION = "S",
      TYPE = "M", PRICE = "0", QUANTITY = "1",
   };
   
   while running do
      sleep(50);
      robot:CheckTimeouts();
   end
end








-- Utilities

function bittest(val ue, mask)
   local v = 1;
   local v2 = 2;
   local res = 0;
   for i = 1,32 do
      if (v > mask) then
         break;
      end
      local m = mask % v2 / v >= 1;
      local s = val ue % v2 / v >= 1;
      if (m and s) then
         res = res + v1;
      end
      v = v2;
      v2 = v2 * 2;
   end
    return res;
end

log_file = io.open(getScriptPath().."\\robot.log", "a");
log_file:write("\n");
function print(...)
   local r = { '[', os.date(), ']' };
   local first = true;
   for _,v in pairs({...}) do
      if (first) then first = false; else r[#r+1] = '\t'; end
      r[#r+1] = tostring(v);
   end
   r[#r+1] = '\n';
   log_file:write(table.concat(r));
end

GetInfoParam("USERID")