/// <summary>
/// Metodo responsável por efetuar o controle de risco e tratamento da solicitação de cancelamento de oferta.
/// </summary>
/// <param name="pParametroCancelamentoRequest">Dados do cancelamento da oferta</param>
/// <returns>EnviarCancelamentoOrdemResponse</returns>
public ExecutarCancelamentoOrdemResponse CancelarOrdem(EnviarCancelamentoOrdemRequest pParametroCancelamentoRequest)
{
ExecutarCancelamentoOrdemResponse _response = new ExecutarCancelamentoOrdemResponse();
logger.Info("TRACE DA SOLICITACAO DE CANCELAMENTO DE ORDENS:..........:");
logger.Info("**************************** INICIO **********************************");
logger.Info("CodigoCliente:......................................:" + DateTime.Now.ToString());
logger.Info("OrderID:............................................:" + pParametroCancelamentoRequest.ClienteCancelamentoInfo.Account.ToString());
logger.Info("OrigClOrdID:........................................:" + pParametroCancelamentoRequest.ClienteCancelamentoInfo.OrigClOrdID.ToString());
logger.Info("PortaControleOrdem:.................................:" + pParametroCancelamentoRequest.ClienteCancelamentoInfo.ChannelID.ToString());
logger.Info("**************************** FIM ************************************");
try{
logger.Info("******* INICIA O PROCESSAMENTO DO CANCELAMENTO ********");
_response = new ProcessarOrdem().
CancelarOrdem(pParametroCancelamentoRequest);
logger.Info("******* FINALIZA O PROCESSAMENTO DO CANCELAMENTO ******");
}
catch (Exception ex) {
logger.Error("Ocorreu um erro ao invocar o método CancelarOrdem.", ex);
}
return(_response);
}
private ExecutarCancelamentoOrdemResponse EnfileirarCancelamento(ExecutarCancelamentoOrdemRequest request)
{
ExecutarCancelamentoOrdemResponse response = new ExecutarCancelamentoOrdemResponse();
string msg = "Cancelamento de Ordem enviado com sucesso";
StatusRoteamentoEnum status = StatusRoteamentoEnum.Sucesso;
response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
queueCancelamento.Enqueue(request);
return(response);
}
private void btnCancelar_Click(object sender, EventArgs e)
{
ExecutarCancelamentoOrdemResponse EnviarCancelamentoOrdemResponse = new ExecutarCancelamentoOrdemResponse();
EnviarCancelamentoOrdemRequest EnviarCancelamentoOrdemRequest = new EnviarCancelamentoOrdemRequest();
ServicoOrdens ServicoOrdens = new ServicoOrdens();
//IServicoOrdens ServicoOrdens = Ativador.Get<IServicoOrdens>();
EnviarCancelamentoOrdemRequest.ClienteCancelamentoInfo.OrigClOrdID = txtNumeroControle.Text;
EnviarCancelamentoOrdemRequest.ClienteCancelamentoInfo.Account = int.Parse(txtCliente.Text);
EnviarCancelamentoOrdemRequest.ClienteCancelamentoInfo.ChannelID = int.Parse(txtChannelID.Text);
EnviarCancelamentoOrdemRequest.ClienteCancelamentoInfo.Symbol = txtPapel.Text;
EnviarCancelamentoOrdemResponse = ServicoOrdens.CancelarOrdem(EnviarCancelamentoOrdemRequest);
MessageBox.Show(EnviarCancelamentoOrdemResponse.DadosRetorno.Ocorrencias[0].Ocorrencia);
MessageBox.Show("Ordem cancelada com sucesso.");
this.CalularLimites();
}
private void cancelarOrdem(OrdemInfo ordem)
{
try
{
OrdemCancelamentoInfo info = new OrdemCancelamentoInfo();
info.ClOrdID = DateTime.Now.ToString("yyyyMMddHHmmssfff") + "-C" + ordem.Symbol + ordem.ChannelID + ordem.Account;
info.Account = ordem.Account;
info.ChannelID = ordem.ChannelID;
info.Exchange = ordem.Exchange;
info.OrigClOrdID = ordem.ClOrdID;
info.Symbol = ordem.Symbol;
info.SecurityID = ordem.SecurityID;
info.Side = ordem.Side;
if (!String.IsNullOrEmpty(ordem.ExecBroker))
{
info.ExecBroker = ordem.ExecBroker;
}
ExecutarCancelamentoOrdemRequest request = new ExecutarCancelamentoOrdemRequest();
IRoteadorOrdens roteador = Ativador.Get <IRoteadorOrdens>();
ExecutarCancelamentoOrdemResponse response = roteador.CancelarOrdem(request);
if (response.DadosRetorno.StatusResposta != StatusRoteamentoEnum.Sucesso)
{
logger.Error("Erro ao cancelar ordem [" + ordem.ClOrdID + "] alteracao de [" + ordem.ClOrdID + "]");
foreach (OcorrenciaRoteamentoOrdem ocorr in response.DadosRetorno.Ocorrencias)
{
logger.Error("Erro: " + ocorr.Ocorrencia);
}
}
}
catch (Exception ex)
{
logger.Error("cancelarOrdem(): " + ex.Message, ex);
}
}
/// <summary>
/// Exclui as ordens selecionadas
/// </summary>
/// <returns>Retorna uma string com mensagem de sucesso ou erro ao excluir as ordens</returns>
private string ResponderExcluirOrdens()
{
string lRetorno = string.Empty;
try
{
string lIds = Request.Form["Ids"];
string lPortas = Request.Form["Portas"];
string lMensagem = "";
List <string> lstIdOrdem = new List <string>();
//IServicoOrdens lOrdem = Ativador.Get<IServicoOrdens>();
Gradual.Core.Ordens.Lib.IServicoOrdens lOrdem = Ativador.Get <Gradual.Core.Ordens.Lib.IServicoOrdens>();
Dictionary <string, string> lCriticas = new Dictionary <string, string>();
ExecutarCancelamentoOrdemResponse lResponse = new ExecutarCancelamentoOrdemResponse();
string[] Ordens = lIds.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] Portas = lPortas.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
OrdemCancelamentoInfo info;
EnviarCancelamentoOrdemRequest lRequestCancel;
for (int i = 0; i < Ordens.Length; i++)
{
info = new OrdemCancelamentoInfo();
info.OrigClOrdID = Ordens[i];
info.ChannelID = int.Parse(Portas[i]);
lRequestCancel = new EnviarCancelamentoOrdemRequest()
{
ClienteCancelamentoInfo = info
};
lResponse = lOrdem.CancelarOrdem(lRequestCancel);
if (lResponse.DadosRetorno.StatusResposta != StatusRoteamentoEnum.Sucesso)
{
lCriticas.Add(info.OrderID, lResponse.DadosRetorno.StackTrace);
}
}
if (lCriticas.Count > 0)
{
foreach (KeyValuePair <string, string> critica in lCriticas)
{
lMensagem += string.Concat("Ordem: ", critica.Key, "Crítica - ", critica.Value);
}
lRetorno = RetornarSucessoAjax(lMensagem);
}
else
{
lRetorno = RetornarSucessoAjax("Orden(s) cancelada(s) com sucesso");
base.RegistrarLogExclusao(string.Concat("Foram EXCLUÍDAS as seguintes ordens: ", lIds));
}
}
catch (Exception ex)
{
lRetorno = base.RetornarErroAjax("Erro ao tentar cancelar ordem.", ex);
}
return(lRetorno);
}
/// <summary>
/// Envia um pedido de cancelamento de ordem para o canal correspondente
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ExecutarCancelamentoOrdemResponse CancelarOrdem(ExecutarCancelamentoOrdemRequest request)
{
ExecutarCancelamentoOrdemResponse response = new ExecutarCancelamentoOrdemResponse();
CanalInfo _canal = null;
StatusRoteamentoEnum status = StatusRoteamentoEnum.Sucesso;
string msg = "Cancelamento Enviado";
logger.Debug("Request de Cancelamento Recebido:");
logger.Debug("Cliente ......: " + request.info.Account);
logger.Debug("Bolsa ........: " + request.info.Exchange);
logger.Debug("Canal ........: " + request.info.ChannelID);
logger.Debug("Order ID .....: " + request.info.OrderID);
logger.Debug("OrigClOrdID ..: " + request.info.OrigClOrdID);
logger.Debug("ClOrdID ......: " + request.info.ClOrdID);
try
{
_canal = (CanalInfo)_canais[request.info.Exchange + request.info.ChannelID];
if (!_bKeepRunning)
{
msg = "Servico esta em finalizacao";
status = StatusRoteamentoEnum.Erro;
logger.Info(msg);
response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
return(response);
}
if (_canal == null)
{
msg = "Nao ha canal configurado para " + request.info.Exchange + "-" + request.info.ChannelID;
status = StatusRoteamentoEnum.Erro;
logger.Info(msg);
response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
}
else
{
if (_canal.roteador == null || _canal.Conectado == false)
{
status = StatusRoteamentoEnum.Erro;
msg = "Nao ha canal ativo e conectado para " + request.info.Exchange + "-" + request.info.ChannelID;
logger.Info(msg);
response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
}
else
{
response = EnfileirarCancelamento(request);
}
}
}
catch (Exception ex)
{
msg = "CancelarOrdem(): " + ex.Message;
status = StatusRoteamentoEnum.Erro;
logger.Error(msg + "-" + ex.StackTrace);
response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
if (_canal != null)
{
_resetCanal(_canal);
}
}
logger.Info(msg);
logger.Debug("Request de Cancelamento Recebido:");
return(response);
}
/// <summary>
/// Exclui as ordens selecionadas
/// </summary>
/// <returns>Retorna uma string com mensagem de sucesso ou erro ao excluir as ordens</returns>
private string ResponderExcluirOrdens()
{
string lRetorno = string.Empty;
try
{
string lIds = Request.Form["Ids"];
string lPortas = Request.Form["Portas"];
string lAccounts = Request.Form["Accounts"];
string lSymbols = Request.Form["Symbols"];
string lMensagem = "";
List <string> lstIdOrdem = new List <string>();
//IServicoOrdens lOrdem = Ativador.Get<IServicoOrdens>();
Gradual.Core.Ordens.Lib.IServicoOrdens lOrdem = Ativador.Get <Gradual.Core.Ordens.Lib.IServicoOrdens>();
Dictionary <string, string> lCriticas = new Dictionary <string, string>();
ExecutarCancelamentoOrdemResponse lResponse = new ExecutarCancelamentoOrdemResponse();
string[] Ordens = lIds.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] Portas = lPortas.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] Accounts = lAccounts.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] Symbols = lSymbols.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
//OrdemCancelamentoInfo info;
//EnviarCancelamentoOrdemRequest lRequestCancel;
for (int i = 0; i < Ordens.Length; i++)
{
IFixServerLowLatencyAdm fixAdm = Ativador.Get <IFixServerLowLatencyAdm>();
OrderCancelingRequest req = new OrderCancelingRequest();
req.Account = Accounts[i];
req.OrigClOrdID = Ordens[i];
req.ChannelID = Portas[i];
req.Symbol = Symbols[i];
OrderCancelingResponse resp = fixAdm.CancelOrder(req);
/*
* info = new OrdemCancelamentoInfo();
*
* info.OrigClOrdID = Ordens[i];
*
* info.ChannelID = int.Parse( Portas[i]);
*
* lRequestCancel = new EnviarCancelamentoOrdemRequest()
* {
* ClienteCancelamentoInfo = info
* };
*
* lResponse = lOrdem.CancelarOrdem(lRequestCancel);
*/
if (resp.StatusResponse == 0 && !string.IsNullOrEmpty(resp.DescricaoErro))
{
lCriticas.Add(req.OrigClOrdID, resp.DescricaoErro);
}
}
if (lCriticas.Count > 0)
{
foreach (KeyValuePair <string, string> critica in lCriticas)
{
lMensagem += string.Concat("Ordem: ", critica.Key, "Crítica - ", critica.Value);
}
lRetorno = RetornarSucessoAjax(lMensagem);
}
else
{
lRetorno = RetornarSucessoAjax("Orden(s) cancelada(s) com sucesso");
base.RegistrarLogExclusao(string.Concat("Foram EXCLUÍDAS as seguintes ordens: ", lIds));
}
}
catch (Exception ex)
{
lRetorno = base.RetornarErroAjax("Erro ao tentar cancelar ordem.", ex);
}
return(lRetorno);
}
/// <summary>
/// Cancelamento da ordem
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btCancelar_Click(object sender, EventArgs e)
{
try
{
OrdemCancelamentoInfo ordem = new OrdemCancelamentoInfo();
ordem.ClOrdID = txtClOrdID.Text;
ordem.OrigClOrdID = txtOrigOrdID.Text;
ordem.ChannelID = Convert.ToInt32(txtOperador.Text);
if (cmbBolsa.SelectedItem.Equals("BOVESPA"))
{
ordem.Exchange = "BOVESPA";
}
else
{
ordem.Exchange = "BMF";
}
ordem.OrderID = txtExchangeNumber.Text;
ordem.Account = Convert.ToInt32(txtCodCliente.Text);
ordem.Symbol = txtPapel.Text;
ordem.SecurityID = txtSecurityId.Text;
ordem.ExecBroker = txtTraderID.Text;
ordem.Memo5149 = "Cancelto " + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss.fff");
if (txtSenderLocation.Text.Length > 0)
{
ordem.SenderLocation = txtSenderLocation.Text;
}
if (txtExecTrader.Text.Length > 0)
{
ordem.ExecutingTrader = txtExecTrader.Text;
}
/*if (!String.IsNullOrEmpty(txtCompIDBolsa.Text))
* {
* ordem.CompIDBolsa = txtCompIDBolsa.Text;
* }*/
if (rdCompra.Checked)
{
ordem.Side = OrdemDirecaoEnum.Compra;
}
else
{
ordem.Side = OrdemDirecaoEnum.Venda;
}
ordem.OrderQty = Convert.ToInt32(txtQtde.Text);
IRoteadorOrdens roteador = Ativador.Get <IRoteadorOrdens>();
if (roteador != null)
{
ExecutarCancelamentoOrdemRequest request = new ExecutarCancelamentoOrdemRequest();
request.info = ordem;
ExecutarCancelamentoOrdemResponse resp = roteador.CancelarOrdem(request);
if (resp.DadosRetorno != null)
{
string msg = "";
foreach (OcorrenciaRoteamentoOrdem ocorr in resp.DadosRetorno.Ocorrencias)
{
msg += ocorr.Ocorrencia + "\r\n";
}
if (resp.DadosRetorno.StatusResposta == StatusRoteamentoEnum.Erro)
{
MessageBox.Show(msg);
}
else
{
_addMsg(msg);
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);
logger.Error("Erro: " + ex.Message, ex);
}
}
/// <summary>
/// Método responsável por enviar um cancelamento de ordens para o roteador cancelar.
/// </summary>
/// <param name="pParametroCancelamentoRequest"></param>
/// <returns></returns>
public EnviarCancelamentoOrdemResponse CancelarOrdem(EnviarCancelamentoOrdemRequest pParametroCancelamentoRequest)
{
logger.Info("Iniciar rotina de cancelamento de ordens");
DateTime DataInicioExecucao = DateTime.Now;
logger.Info("Data de inicio de execução: " + DataInicioExecucao.ToString());
EnviarCancelamentoOrdemResponse CancelamentoOrderResponse = new EnviarCancelamentoOrdemResponse();
OrdemFIXResponse <OrdemCancelamentoInfo> OrdemCancelamentoInfo = this.ParsearOrdemCancelamentoCliente(pParametroCancelamentoRequest.ClienteCancelamentoInfo);
if (OrdemCancelamentoInfo.StatusResposta == CriticaRiscoEnum.Sucesso)
{
logger.Info("Solicitação de cancelamento de ordem enviado ");
logger.Info("Bovespa : " + OrdemCancelamentoInfo.Objeto.Account.ToString());
logger.Info("ChannelID : " + OrdemCancelamentoInfo.Objeto.ChannelID.ToString());
logger.Info("ClOrdID : " + OrdemCancelamentoInfo.Objeto.ClOrdID.ToString());
logger.Info("Exchange : " + OrdemCancelamentoInfo.Objeto.Exchange.ToString());
logger.Info("OrderID : " + OrdemCancelamentoInfo.Objeto.OrderID.ToString());
logger.Info("OrigClOrdID : " + OrdemCancelamentoInfo.Objeto.OrigClOrdID.ToString());
logger.Info("Side : " + OrdemCancelamentoInfo.Objeto.Side.ToString());
logger.Info("Symbol : " + OrdemCancelamentoInfo.Objeto.Symbol.ToString());
logger.Info("Mensagem parseado com sucesso!");
logger.Info("Inicializa serviço de roteamento de ordem");
//Invoca o serviço de roteamento de ordem
IRoteadorOrdens ServicoRoteador = Ativador.Get <IRoteadorOrdens>();
logger.Info("Serviço do ativador inicializado com sucesso");
logger.Info("Calculando digito do cliente");
OrdemCancelamentoInfo.Objeto.Account = RetornaCodigoCliente(CodigoCorretora, OrdemCancelamentoInfo.Objeto.Account);
logger.Info("Envia ordem para o roteador");
// Enviar a ordem para o roteador de ordens e aguarda o retorno.
ExecutarCancelamentoOrdemResponse RespostaOrdem = ServicoRoteador.CancelarOrdem(
new ExecutarCancelamentoOrdemRequest()
{
info = OrdemCancelamentoInfo.Objeto
});
if (RespostaOrdem.DadosRetorno.StatusResposta == StatusRoteamentoEnum.Sucesso)
{
logger.Info("Cancelamento enviado com sucesso.");
CancelamentoOrderResponse.DescricaoResposta = RespostaOrdem.DadosRetorno.Ocorrencias[0].Ocorrencia;
CancelamentoOrderResponse.DataResposta = DateTime.Now;
CancelamentoOrderResponse.StatusResposta = CriticaRiscoEnum.Sucesso;
}
else
{
logger.Info("Erro ao enviar o cancelamento para o Roteador.");
CancelamentoOrderResponse.DescricaoResposta = RespostaOrdem.DadosRetorno.Ocorrencias[0].Ocorrencia;
CancelamentoOrderResponse.DataResposta = DateTime.Now;
CancelamentoOrderResponse.StatusResposta = CriticaRiscoEnum.ErroNegocio;
}
}
else
{
CancelamentoOrderResponse.DescricaoResposta = OrdemCancelamentoInfo.CriticaInfo[0].Critica.ToString();
CancelamentoOrderResponse.CriticaInfo = OrdemCancelamentoInfo.CriticaInfo;
CancelamentoOrderResponse.DataResposta = DateTime.Now;
CancelamentoOrderResponse.StatusResposta = CriticaRiscoEnum.Sucesso;
}
TimeSpan datafinal = (DateTime.Now - DataInicioExecucao);
logger.Info("Tempo total de execução :" + datafinal.ToString());
return(CancelamentoOrderResponse);
}
