public static List <OrdemInfo> LoadOfertas()
{
Stream stream = null;
List <OrdemInfo> lista = new List <OrdemInfo>();
//string path = ConfigurationManager.AppSettings["ArquivoOrdens"].ToString();
try
{
stream = File.Open("orders.dat", FileMode.Open);
BinaryFormatter bformatter = new BinaryFormatter();
long qtdeitens = (long)bformatter.Deserialize(stream);
for (int i = 0; i < qtdeitens; i++)
{
OrdemInfo info = (OrdemInfo)bformatter.Deserialize(stream);
lista.Add(info);
}
stream.Close();
stream = null;
}
catch (Exception ex)
{
if (stream != null)
{
stream.Close();
}
}
return(lista);
}
private void OnChegadaDeAcompanhamento(OrdemInfo pAlteracao)
{
if (ChegadaDeAcompanhamento != null)
{
ChegadaDeAcompanhamento(pAlteracao);
}
}
/// <summary>
///
/// </summary>
/// <param name="parametro"></param>
/// <param name="ativo"></param>
private void executarTesteAtivo(ParametroTesteConfig parametro, string ativo, OrdemDirecaoEnum sentido)
{
logger.InfoFormat("Executando teste com [{0}] [{1}] [{2}] [{3}]", parametro.Bolsa, parametro.Porta, ativo, parametro.Account, parametro.EnteringTrader);
logger.Info("Enviando nova ordem para " + ativo);
OrdemInfo ordem = enviarNovaOrdem(parametro, ativo, sentido);
logger.Info("Alterando ordem de " + ativo + " clOrdID [" + ordem.ClOrdID + "]");
Thread.Sleep(1500);
OrdemInfo ordemAlterada = alterarOrdem(ordem);
if (dctOrdens.ContainsKey(ordemAlterada.ClOrdID))
{
if (dctOrdens[ordemAlterada.ClOrdID].OrdStatus == OrdemStatusEnum.NOVA ||
dctOrdens[ordemAlterada.ClOrdID].OrdStatus == OrdemStatusEnum.PARCIALMENTEEXECUTADA ||
dctOrdens[ordemAlterada.ClOrdID].OrdStatus == OrdemStatusEnum.SUBSTITUIDA)
{
logger.Info("Cancelando ordem [" + ordemAlterada.ClOrdID + "]");
Thread.Sleep(1500);
cancelarOrdem(ordemAlterada);
}
}
logger.InfoFormat("Final do teste de [{0}] [{1}] [{2}] [{3}]", parametro.Bolsa, parametro.Porta, ativo, parametro.Account, parametro.EnteringTrader);
}
private ExecutarOrdemResponse EnviarOrdemRoteador(OrdemInfo OrdemInfo)
{
try
{
// Instancia servico de ordens
logger.Info("Invoca servico de roteamento de ordens");
IRoteadorOrdens ServicoRoteador = Ativador.Get <IRoteadorOrdens>();
OrdemInfo.TransactTime = DateTime.Now;
// Envia a ordem para o reteador e aguarda o retorno
logger.Info("Envia a ordem para o roteador");
ExecutarOrdemResponse RespostaOrdem =
ServicoRoteador.ExecutarOrdem(new RoteadorOrdens.Lib.Mensagens.ExecutarOrdemRequest()
{
info = OrdemInfo
});
return(RespostaOrdem);
}
catch (Exception ex)
{
logger.Info("Ocorreu um erro ao enviar a ordem para o roteador");
logger.Info("Descrição :" + ex.Message);
throw (ex);
}
}
/// <summary>
/// Carrega os detalhes
/// </summary>
/// <returns></returns>
public string ResponderCarregarDetalhes()
{
string lRetorno = string.Empty;
var lstAcompanhamentos = from lista in SessionUltimoResultadoDeBusca where lista.ClOrdID == Request["id"].ToString() select lista;
List <TransporteOrdemDetalhe> lDetalhes = new List <TransporteOrdemDetalhe>();
List <OrdemInfo> lOrdens = lstAcompanhamentos.ToList <OrdemInfo>();
OrdemInfo lOrdem = lOrdens[0];
if (null != lstAcompanhamentos)
{
lOrdem.Acompanhamentos.ForEach(lAcompanhamento =>
{
lDetalhes.Add(new TransporteOrdemDetalhe(lAcompanhamento));
});
}
TransporteDeListaPaginada lLista = new TransporteDeListaPaginada(lDetalhes);
lRetorno = JsonConvert.SerializeObject(lLista);
return(lRetorno);
}
/// <summary>
///
/// </summary>
/// <param name="report"></param>
public void OrdemAlterada(OrdemInfo report)
{
// Envia o report para os assinantes
logger.Debug("On OrdemAlterada(): recebeu report ");
TradutorFix.DumpOrdemInfo(report);
lock (_executionsReportsSubscribers)
{
if (_executionsReportsSubscribers.Count > 0)
{
_sendExecutionReport(report);
}
else
{
_enqueueExecutionReport(report);
}
}
// Reseta o contador do heartbeat
lock (_canais)
{
if (_canais.ContainsKey(report.Exchange + report.ChannelID))
{
CanalInfo canal = (CanalInfo)_canais[report.Exchange + report.ChannelID];
canal.Conectado = true;
canal.LastHeartbeat = _getSecsFromTicks(DateTime.Now.Ticks);
}
}
}
private void _notificaEnvioParaCanal(OrdemInfo ordem)
{
AcompanhamentoOrdemInfo acompanhamento = new AcompanhamentoOrdemInfo();
if (ordem.Acompanhamentos != null && ordem.Acompanhamentos.Count > 0)
{
ordem.Acompanhamentos.Clear();
}
acompanhamento.CodigoDoCliente = ordem.Account;
acompanhamento.CanalNegociacao = ordem.ChannelID;
acompanhamento.Instrumento = ordem.Symbol;
acompanhamento.NumeroControleOrdem = ordem.ClOrdID;
acompanhamento.Preco = Convert.ToDecimal(ordem.Price);
acompanhamento.StatusOrdem = OrdemStatusEnum.ENVIADAPARAOCANAL;
acompanhamento.DataAtualizacao = DateTime.Now;
acompanhamento.QuantidadeSolicitada = ordem.OrderQty;
acompanhamento.Descricao = "Ordem enviada para o servico de canal";
ordem.Acompanhamentos.Add(acompanhamento);
ordem.OrdStatus = OrdemStatusEnum.ENVIADAPARAOCANAL;
_sendExecutionReport(ordem);
}
private void btOk_Click(object sender, EventArgs e)
{
DialogResult = DialogResult.OK;
SelectedOrder = enviadas[cmbOfertas.SelectedIndex];
this.Close();
}
public void addExecutionReport(OrdemInfo report)
{
lock (queueER)
{
queueER.Enqueue(report);
bERqueued = true;
}
}
public void addReport102(OrdemInfo report)
{
lock (queue102)
{
queue102.Enqueue(report);
b102queued = true;
}
}
public void addReport101(OrdemInfo report)
{
lock (queue101)
{
queue101.Enqueue(report);
b101queued = true;
}
}
public void OrdemAlterada(OrdemInfo report)
{
lock (qCallback)
{
qCallback.Enqueue(report);
Monitor.Pulse(qCallback);
}
}
public void OrdemAlterada(OrdemInfo pAlteracao)
{
gLog4Net.Debug("OrdemAlterada():");
Timestamp = _getSecsFromTicks(DateTime.Now.Ticks);
OnChegadaDeAcompanhamento(pAlteracao);
}
/// <summary>
/// Enfileira e persiste os relatorios de execucao
/// </summary>
/// <param name="info">OrdemInfo object</param>
private void _enqueueExecutionReport(OrdemInfo info)
{
lock (_orderReportInfo)
{
logger.Info("Ordem " + info.ClOrdID + " inserida na fila de respostas");
_orderReportInfo.Enqueue(info);
}
}
private OrdemInfo _PreencherOrdemInfo(DataRow dataRow)
{
OrdemInfo ret = new OrdemInfo();
ret.Account = dataRow["CD_CLIENTE"].DBToInt32();
ret.ChannelID = dataRow["CHANNELID"].DBToInt32();
ret.ClOrdID = dataRow["ORDERID"].DBToString();
ret.OrderQty = dataRow["ORDERQTY"].DBToInt32();
ret.OrderQtyRemmaining = dataRow["ORDERQTYREMAINING"].DBToInt32();
ret.CumQty = dataRow["QT_ORDEXEC"].DBToInt32();
int orderstatus = dataRow["ORDSTATUSID"].DBToInt32();
switch (orderstatus)
{
case 0: ret.OrdStatus = OrdemStatusEnum.NOVA; break;
case 1: ret.OrdStatus = OrdemStatusEnum.PARCIALMENTEEXECUTADA; break;
case 2: ret.OrdStatus = OrdemStatusEnum.EXECUTADA; break;
case 4: ret.OrdStatus = OrdemStatusEnum.CANCELADA; break;
default:
ret.OrdStatus = OrdemStatusEnum.EXPIRADA; break;
}
int orderside = dataRow["SIDE"].DBToInt32();
if (orderside == 2)
{
ret.Side = OrdemDirecaoEnum.Venda;
}
else
{
ret.Side = OrdemDirecaoEnum.Compra;
}
ret.RegisterTime = DateTime.ParseExact(dataRow["REGISTERTIME"].DBToString(), "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
ret.ExpireDate = dataRow["EXPIREDATE"].DBToDateTime();
ret.Price = dataRow["PRICE"].DBToDouble().Value;
ret.Symbol = dataRow["SYMBOL"].DBToString();
//TODO: preencher os campos
gLog4Net.DebugFormat("ORDID[{0}] CLI[{1}] CH[{2}] SIDE[{3}] QTY[{4}] ST[{5}] PR[{6}] SYMB[{7}]",
ret.ClOrdID,
ret.Account,
ret.ChannelID,
orderside,
ret.OrderQty,
orderstatus,
ret.Price,
ret.Symbol);
return(ret);
}
public void OrdemAlterada(OrdemInfo info)
{
gLog4Net.Debug("DropCopy OrdemAlterada():");
Timestamp = _getSecsFromTicks(DateTime.Now.Ticks);
if (OnFIXDropCopy != null)
{
OnFIXDropCopy(info);
}
}
private OrdemInfo GerarAcompanhamentoAleatorio(ref Random pRand)
{
OrdemInfo lRetornoOrdem;
AcompanhamentoOrdemInfo lRetorno = new AcompanhamentoOrdemInfo();
lRetorno.CanalNegociacao = 1;
lRetorno.DataAtualizacao = DateTime.Now;
lRetorno.DataOrdemEnvio = DateTime.Now.AddSeconds(pRand.Next(-30, -1));
lRetorno.DataValidade = DateTime.Now.AddDays(1);
lRetorno.Direcao = (pRand.Next(0, 1) == 0) ?
OrdemDirecaoEnum.Compra
: OrdemDirecaoEnum.Venda;
lRetorno.Instrumento = gInstrumentos[pRand.Next(0, 9)];
lRetorno.NumeroControleOrdem = string.Format("{0}", gAcompanhamentosParaEnviar.Count + 1);
lRetorno.CodigoResposta = string.Format("r-{0}", lRetorno.NumeroControleOrdem);
lRetorno.CodigoTransacao = string.Format("t-{0}", lRetorno.NumeroControleOrdem);
lRetorno.Preco = (decimal)pRand.Next(100, 500) * (decimal)pRand.NextDouble();
lRetorno.QuantidadeSolicitada = pRand.Next(1, 50) * 100;
lRetorno.QuantidadeExecutada = pRand.Next(20, 50) * 100;
if (lRetorno.QuantidadeExecutada > lRetorno.QuantidadeSolicitada)
{
lRetorno.QuantidadeExecutada = lRetorno.QuantidadeSolicitada;
}
if (lRetorno.QuantidadeExecutada == lRetorno.QuantidadeSolicitada)
{
lRetorno.StatusOrdem = OrdemStatusEnum.EXECUTADA;
}
else
{
lRetorno.StatusOrdem = OrdemStatusEnum.PARCIALMENTEEXECUTADA;
}
//lRetornoOrdem = new OrdemInfo(lRetorno);
lRetornoOrdem = new OrdemInfo();
lRetornoOrdem.Acompanhamentos.Add(lRetorno);
return(lRetornoOrdem);
}
/// <summary>
/// </summary>
/// <param name="pInfo"></param>
public void TrocarNumeroControleOrdem(OrdemInfo pInfo)
{
AbrirConexao();
gComando = new SqlCommand("prc_troca_numerocontrole", gConexao);
gComando.CommandType = System.Data.CommandType.StoredProcedure;
gComando.Parameters.Add(new SqlParameter("@pClOrdID", pInfo.ClOrdID));
gComando.ExecuteNonQuery();
FecharConexao();
}
private OrdemInfo enviarNovaOrdem(ParametroTesteConfig parametro, string ativo, OrdemDirecaoEnum sentido)
{
OrdemInfo ordem = new OrdemInfo();
ordem.ClOrdID = DateTime.Now.ToString("yyyyMMddHHmmssfff") + "-" + ativo + parametro.Porta + parametro.Account;
ordem.Account = Convert.ToInt32(parametro.Account);
ordem.OrdType = OrdemTipoEnum.Limitada;
ordem.TimeInForce = OrdemValidadeEnum.ValidaParaODia;
ordem.Symbol = ativo;
ordem.SecurityID = ativo;
ordem.Price = obterPrecoOrdem(ativo);
ordem.Exchange = parametro.Bolsa;
ordem.ChannelID = Convert.ToInt32(parametro.Porta);
ordem.Side = sentido;
ordem.OrdStatus = OrdemStatusEnum.ENVIADAPARAOROTEADORDEORDENS;
ordem.OrderQty = parametro.Qtde;
ordem.RegisterTime = DateTime.Now;
if (String.IsNullOrEmpty(parametro.EnteringTrader))
{
ordem.ExecBroker = "227";
}
else
{
ordem.ExecBroker = parametro.EnteringTrader;
}
lock (dctOrdens)
{
dctOrdens.Add(ordem.ClOrdID, ordem);
}
ExecutarOrdemRequest request = new ExecutarOrdemRequest();
request.info = ordem;
IRoteadorOrdens roteador = Ativador.Get <IRoteadorOrdens>();
ExecutarOrdemResponse response = roteador.ExecutarOrdem(request);
if (response.DadosRetorno.StatusResposta != StatusRoteamentoEnum.Sucesso)
{
logger.Error("Erro ao enviar ordem [" + ordem.ClOrdID + "]");
foreach (OcorrenciaRoteamentoOrdem ocorr in response.DadosRetorno.Ocorrencias)
{
logger.Error("Erro: " + ocorr.Ocorrencia);
}
}
return(ordem);
}
/// <summary>
/// Imprime o conteudo dos campos do objeto OrdemInfo
/// </summary>
/// <param name="ordem">objeto OrdemInfo</param>
public static void DumpOrdemInfo(OrdemInfo ordem)
{
if (logger.IsDebugEnabled)
{
logger.Debug("Account ...........: " + ordem.Account);
logger.Debug("ID da Ordem (DB) ..: " + ordem.IdOrdem);
logger.Debug("Numero da ordem ...: " + ordem.ClOrdID);
logger.Debug("ExchangeNumber ....: " + ordem.ExchangeNumberID);
logger.Debug("Bolsa .............: " + ordem.Exchange);
logger.Debug("Operador...........: " + ordem.ChannelID);
logger.Debug("OrigClOrdID .......: " + ordem.OrigClOrdID);
logger.Debug("Symbol ............: " + ordem.Symbol);
logger.Debug("Status ............: " + ordem.OrdStatus);
logger.Debug("Side ..............: " + ordem.Side);
logger.Debug("TimeInForce .......: " + ordem.TimeInForce);
logger.Debug("TransactTime ......: " + ordem.TransactTime.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
logger.Debug("OrderType .........: " + ordem.OrdType.ToString());
logger.Debug("Qtde .............: " + ordem.OrderQty);
logger.Debug("Qtde Pendente .....: " + ordem.OrderQtyRemmaining);
logger.Debug("Preco .............: " + ordem.Price);
logger.Debug("Preco Stop ........: " + ordem.StopPrice);
logger.Debug("Register Time ....: " + ordem.RegisterTime.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
logger.Debug("Qtde Aparente .....: " + ordem.MaxFloor);
logger.Debug("Qtde minima .......: " + ordem.MinQty);
logger.Debug("Expiration Date ...: " + (ordem.ExpireDate.HasValue? ordem.ExpireDate.Value.ToString("yyyy/MM/dd HH:mm:ss.fffffff") : "--"));
if (ordem.Acompanhamentos != null)
{
int i = 0;
foreach (AcompanhamentoOrdemInfo acomp in ordem.Acompanhamentos)
{
logger.Debug("Acompanhamento : " + i);
logger.Debug("(A) DataAtualizacao ......: " + acomp.DataAtualizacao.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
logger.Debug("(A) CodigoRejeicao .......: " + acomp.CodigoRejeicao);
logger.Debug("(A) Descricao ............: " + acomp.Descricao);
logger.Debug("(A) Qtde Exc .............: " + acomp.QuantidadeExecutada);
logger.Debug("(A) Qtde Solicitada ......: " + acomp.QuantidadeSolicitada);
logger.Debug("(A) Status Ordem .........: " + acomp.StatusOrdem);
logger.Debug("(A) NumeroControleOrdem ..: " + acomp.NumeroControleOrdem);
logger.Debug("(A) CodigoResposta .......: " + acomp.CodigoResposta);
logger.Debug("(A) Data Envio Ordem ...: " + acomp.DataOrdemEnvio.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
logger.Debug("(A) Data Validade ........: " + acomp.DataValidade.ToString("yyyy/MM/dd HH:mm:ss.fffffff"));
i++;
}
}
} //if (logger.IsDebugEnabled)
}
public frmOfertasEnviadas()
{
InitializeComponent();
for (int i = 0; i < enviadas.Count; i++)
{
OrdemInfo info = enviadas[i];
cmbOfertas.Items.Add(info.ClOrdID + "-" + info.Symbol + "-" + info.Price + "-" + info.OrderQty + "-" + info.OrdStatus.ToString());
}
if (cmbOfertas.Items.Count > 0)
{
cmbOfertas.SelectedIndex = 0;
}
}
/// <summary>
/// Envia o relatorio de execucao para os assinantes
/// </summary>
/// <param name="order">objeto OrdemInfo</param>
private void _dispatchExecutionReport(OrdemInfo order)
{
List <IRoteadorOrdensCallback> toDelete = new List <IRoteadorOrdensCallback>();
try
{
lock (_executionsReportsSubscribers)
{
foreach (IRoteadorOrdensCallback subscriber in _executionsReportsSubscribers)
{
if (Ativador.IsValidChannel(subscriber))
{
try
{
subscriber.OrdemAlterada(order);
}
catch (Exception ex)
{
logger.Error(ex);
logger.Info("Abortando channel para assinante: " + subscriber.ToString());
Ativador.AbortChannel(subscriber);
logger.Info("Removendo assinante da lista: " + subscriber.ToString());
toDelete.Add(subscriber);
}
}
else
{
logger.Info("Removendo assinante da lista: " + subscriber.ToString());
toDelete.Add(subscriber);
}
}
// Remove os assinantes abandonados/falhos da lista
foreach (IRoteadorOrdensCallback subscriber in toDelete)
{
_executionsReportsSubscribers.Remove(subscriber);
}
toDelete.Clear();
}
}
catch (Exception ex)
{
logger.Error("Erro em _sendExecutionReport(): " + ex.Message, ex);
}
}
private void ProcessadorCallback()
{
OrdemInfo info = null;
while (_bKeepRunning)
{
try
{
lock (qCallback)
{
if (qCallback.Count > 0)
{
info = qCallback.Dequeue();
}
else
{
if (!Monitor.Wait(qCallback, 100))
{
continue;
}
}
}
lock (dctOrdens)
{
if (dctOrdens.ContainsKey(info.ClOrdID))
{
dctOrdens[info.ClOrdID] = info;
}
if (info.OrdStatus == OrdemStatusEnum.SUBSTITUIDA)
{
if (dctOrdens.ContainsKey(info.OrigClOrdID))
{
dctOrdens.Remove(info.OrigClOrdID);
}
}
}
}
catch (Exception ex)
{
logger.Error("ProcessadorCallback: " + ex.Message, ex);
}
}
}
/// <summary>
/// Cria um novo objeto OrdemInfo a partir do objeto fornecido
/// </summary>
/// <param name="ordem">OrdemInfo a </param>
/// <returns></returns>
public static OrdemInfo CloneOrder(OrdemInfo ordem)
{
OrdemInfo clone = new OrdemInfo();
clone.Account = ordem.Account;
clone.Acompanhamentos.AddRange(ordem.Acompanhamentos.GetRange(0, ordem.Acompanhamentos.Count));
clone.ChannelID = ordem.ChannelID;
clone.ClOrdID = ordem.ClOrdID;
clone.CumQty = ordem.CumQty;
clone.Exchange = ordem.Exchange;
clone.ExchangeNumberID = ordem.ExchangeNumberID;
clone.ExecBroker = ordem.ExecBroker;
clone.ExpireDate = ordem.ExpireDate;
clone.FixMsgSeqNum = ordem.FixMsgSeqNum;
clone.IdOrdem = ordem.IdOrdem;
clone.MaxFloor = ordem.MaxFloor;
clone.MinQty = ordem.MinQty;
clone.OrderQty = ordem.OrderQty;
clone.OrderQtyRemmaining = ordem.OrderQtyRemmaining;
clone.OrdStatus = ordem.OrdStatus;
clone.OrdType = ordem.OrdType;
clone.OrigClOrdID = ordem.OrigClOrdID;
clone.Price = ordem.Price;
clone.RegisterTime = ordem.RegisterTime;
clone.SecurityExchangeID = ordem.SecurityExchangeID;
clone.SecurityID = ordem.SecurityID;
clone.SecurityIDSource = ordem.SecurityIDSource;
clone.Side = ordem.Side;
clone.StopPrice = ordem.StopPrice;
clone.StopStartID = ordem.StopStartID;
clone.Symbol = ordem.Symbol;
clone.TimeInForce = ordem.TimeInForce;
clone.TransactTime = ordem.TransactTime;
clone.PositionEffect = ordem.PositionEffect;
clone.ProtectionPrice = ordem.ProtectionPrice;
clone.Currency = ordem.Currency;
clone.ForeignFirm = ordem.ForeignFirm;
clone.Memo5149 = ordem.Memo5149;
clone.AcountType = ordem.AcountType;
return(clone);
}
/// <summary>
/// Adiciona a ordem a lista de ordens negociadas no dia do cliente e instrumento discriminados separando os acompanhamentos relevantes a posição
/// </summary>
/// <param name="Ordem">Ordem recebida pela bolsa</param>
/// <returns>Posição do cliente já calculada com base na ordem recebida</returns>
public Posicao Add(OrdemInfo Ordem)
{
try
{
// Separa os acompanhamento relevantes
var Ocorrencias = Ordem.Acompanhamentos.AsEnumerable();
Ocorrencias =
from a in Ocorrencias
where
a.StatusOrdem.Equals(OrdemStatusEnum.NOVA) ||
a.StatusOrdem.Equals(OrdemStatusEnum.SUBSTITUIDA) ||
a.StatusOrdem.Equals(OrdemStatusEnum.PARCIALMENTEEXECUTADA) ||
a.StatusOrdem.Equals(OrdemStatusEnum.EXECUTADA) ||
a.StatusOrdem.Equals(OrdemStatusEnum.CANCELADA)
select a;
// Verifica todos osacompanhamentos para identificar os que ainda não foram processados
foreach (AcompanhamentoOrdemInfo acompanhamento in Ocorrencias)
{
// Verifica se o acompanhamento em questão já foi processado através da chave composta pelo Código de Resposta da Bolsa e posição do acompanhamento dentro da ordem
if (!this.Ocorrencias.ContainsKey(String.Format("{0}:{1}", acompanhamento.CodigoResposta, Ordem.Acompanhamentos.IndexOf(acompanhamento).ToString())))
{
// Caso oa companhamento não tenha sido processado
this.Ocorrencias.Add(
String.Format("{0}:{1}", acompanhamento.CodigoResposta, Ordem.Acompanhamentos.IndexOf(acompanhamento).ToString()),
((AcompanhamentoOrdemInfo)acompanhamento)
);
// Processa e efetua os calculos da posição com base no acompanhamento recem recebido
Calcular(((AcompanhamentoOrdemInfo)acompanhamento));
}
}
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("Acompanhamento.Add(): {0}", ex.Message));
}
// Retorna a posição já calculada do cliente para o instrumento discriminado
return(this.Posicao);
}
/// <summary>
/// Método responsavel por guardar uma ordem original em caso de alteracao de ordens
/// </summary>
/// <param name="_ClienteOrdemInfo"></param>
/// <returns></returns>
public bool InserirOrdemBackup(OrdemInfo _ClienteOrdemInfo)
{
try
{
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["GradualOMS"].ConnectionString);
conn.Open();
gComando = new SqlCommand("prc_ins_order_updated", conn);
gComando.CommandType = System.Data.CommandType.StoredProcedure;
gComando.Parameters.Add(new SqlParameter("@OrderID", _ClienteOrdemInfo.IdOrdem));
gComando.Parameters.Add(new SqlParameter("@account", _ClienteOrdemInfo.Account));
gComando.Parameters.Add(new SqlParameter("@instrumento", _ClienteOrdemInfo.Symbol));
gComando.Parameters.Add(new SqlParameter("@CLOrdID", _ClienteOrdemInfo.ClOrdID));
gComando.Parameters.Add(new SqlParameter("@OrdStatusID", (int)_ClienteOrdemInfo.OrdStatus));
gComando.Parameters.Add(new SqlParameter("@price", _ClienteOrdemInfo.Price));
gComando.Parameters.Add(new SqlParameter("@quantidade", _ClienteOrdemInfo.OrderQty));
gComando.Parameters.Add(new SqlParameter("@quantidade_exec", _ClienteOrdemInfo.CumQty));
gComando.Parameters.Add(new SqlParameter("@quantidade_aparente", _ClienteOrdemInfo.MaxFloor));
gComando.Parameters.Add(new SqlParameter("@quantidade_minima", _ClienteOrdemInfo.MinQty));
gComando.Parameters.Add(new SqlParameter("@dt_validade", _ClienteOrdemInfo.ExpireDate));
gComando.ExecuteNonQuery();
FecharConexao(conn);
logger.Info("Backup da ordem a ser alterada inserida no banco de dados com sucesso");
}
catch (Exception ex)
{
logger.Error("Ocorreu um erro ao enviar alteracao ordem para o banco de dados");
logger.Error("Descrição do erro: " + ex.Message, ex);
return(false);
}
return(true);
}
public TransporteResultadoOrdens(OrdemInfo pInfo)
{
Id = string.IsNullOrWhiteSpace(pInfo.ClOrdID.Trim()) ? pInfo.IdOrdem.ToString() : pInfo.ClOrdID;
IdOrdem = pInfo.IdOrdem.ToString();
CompraVenda = OrdemDirecaoEnum.Compra.Equals(pInfo.Side) ? "C" : "V";
CodigoCliente = pInfo.Account.ToString();
Hora = pInfo.RegisterTime.ToString("HH:mm");
NumeroOrdem = pInfo.ClOrdID;
Papel = pInfo.Symbol;
Preco = pInfo.Price.ToString("N2");
Quantidade = pInfo.OrderQty.DBToString();
QuantidadeExecutada = (pInfo.OrderQty - pInfo.OrderQtyRemmaining).DBToString();
Status = this.TraduzirStatus(pInfo.OrdStatus);
Tipo = pInfo.TimeInForce.ToString();
if (Status != "Executada")
{
QuantidadeExecutada = pInfo.CumQty.DBToString();
}
Validade = (pInfo.ExpireDate.Value.ToString("dd/MM/yyyy") != "01/01/0001") ? pInfo.ExpireDate.Value.ToString("dd/MM/yyyy") : "-";
Porta = pInfo.ChannelID.ToString();
PrecoStartStop = pInfo.StopPrice.ToString("N2");
}
private OrdemInfo _CloneOrdemInfo(OrdemInfo info)
{
OrdemInfo clone = new OrdemInfo();
clone.Account = info.Account;
clone.ChannelID = info.ChannelID;
clone.ClOrdID = info.ClOrdID;
clone.CumQty = info.CumQty;
clone.Exchange = info.Exchange;
clone.ExchangeNumberID = info.ExchangeNumberID;
clone.ExecBroker = info.ExecBroker;
clone.ExpireDate = info.ExpireDate;
clone.FixMsgSeqNum = info.FixMsgSeqNum;
clone.IdOrdem = info.IdOrdem;
clone.MaxFloor = info.MaxFloor;
clone.MinQty = info.MinQty;
clone.OrderQty = info.OrderQty;
clone.OrderQtyRemmaining = info.OrderQtyRemmaining;
clone.OrdStatus = info.OrdStatus;
clone.OrdType = info.OrdType;
clone.OrigClOrdID = info.OrigClOrdID;
clone.Price = info.Price;
clone.RegisterTime = info.RegisterTime;
clone.SecurityExchangeID = info.SecurityExchangeID;
clone.SecurityID = info.SecurityID;
clone.SecurityIDSource = info.SecurityIDSource;
clone.Side = info.Side;
clone.StopPrice = info.StopPrice;
clone.StopStartID = info.StopStartID;
clone.Symbol = info.Symbol;
clone.TimeInForce = info.TimeInForce;
clone.TransactTime = info.TransactTime;
clone.CompIDOMS = info.CompIDOMS;
clone.Acompanhamentos.AddRange(info.Acompanhamentos.ToArray());
return(clone);
}
public void AtualizarOrdem(OrdemInfo ordemInfo)
{
AbrirConexao();
gComando = new SqlCommand("prc_update_order", gConexao);
gComando.CommandType = System.Data.CommandType.StoredProcedure;
gComando.Parameters.Add(new SqlParameter("@ClOrdID", ordemInfo.ClOrdID));
gComando.Parameters.Add(new SqlParameter("@OrdStatusId", ordemInfo.OrdStatus));
gComando.Parameters.Add(new SqlParameter("@ExchangeNumberID", ordemInfo.ExchangeNumberID));
gComando.Parameters.Add(new SqlParameter("@OrderQtyRemaining", ordemInfo.OrderQtyRemmaining));
gComando.Parameters.Add(new SqlParameter("@CumQty", ordemInfo.CumQty));
gComando.Parameters.Add(new SqlParameter("@Price", ordemInfo.Price));
if (bSaveFixMsgSeqNum)
{
gComando.Parameters.Add(new SqlParameter("@FixMsgSeqNum", 0));
}
gComando.ExecuteNonQuery();
FecharConexao();
}
public static void AdicionarAcompanhamentoDeOrdem(string pIdDaOrdem, int pContaDoUsuario, string pPapel, decimal pPreco, int pQuantidade)
{
OrdemInfo lInfo;
AcompanhamentoOrdemInfo lAcompanhamento = new AcompanhamentoOrdemInfo();
lAcompanhamento.NumeroControleOrdem = pIdDaOrdem;
lAcompanhamento.CodigoDoCliente = pContaDoUsuario;
lAcompanhamento.Instrumento = pPapel;
lAcompanhamento.Preco = pPreco;
lAcompanhamento.QuantidadeExecutada = pQuantidade;
lAcompanhamento.StatusOrdem = OrdemStatusEnum.EXECUTADA;
lAcompanhamento.CodigoTransacao = "tX-" + pIdDaOrdem;
//lInfo = new OrdemInfo(lAcompanhamento);
lInfo = new OrdemInfo();
lInfo.Acompanhamentos.Add(lAcompanhamento);
gAcompanhamentosParaEnviar.Enqueue(lInfo);
Console.WriteLine("Ordem em fila para envio");
}
