public IndiceGradualQuantidadeTeorica()
{
if (CalcularIndiceGradual)
{
if (ConfigurationManager.AppSettings["IntervaloChecagemArquivo"] != null)
{
gIntervalo = int.Parse(ConfigurationManager.AppSettings["IntervaloChecagemArquivo"]);
}
if (ConfigurationManager.AppSettings["DiretorioChecagemArquivo"] != null)
{
gDiretorio = ConfigurationManager.AppSettings["DiretorioChecagemArquivo"];
}
listaIndices.Clear();
DCotacoes _DCotacoes = new DCotacoes();
listaIndices = _DCotacoes.ObterListaIndicesGradual();
foreach (IndiceGradual.ItemIndice item in listaIndices)
{
logger.Info("Preparado para tratar Indice Gradual[" + item.indice + "] codigo[" + item.codigoIndice + "]");
}
logger.Info("Ativando monitoramento de Arquivo de Quantidades Teoricas (Intervalo = " + gIntervalo + " segs) (Diretorio = " + gDiretorio + ")");
gTimer = new Timer(new TimerCallback(VerificaArquivos), null, 0, gIntervalo * 1000);
}
}
private void DivulgarQuantidadesTeoricas(int codigoIndice, string indice)
{
try
{
DCotacoes _DCotacoes = new DCotacoes();
List <IndiceGradual.ItemComposicaoIndice> lista = _DCotacoes.ObterListaComposicaoIndiceGradual(codigoIndice);
logger.Info("Montando e-mail informativo de atualização de Quantidades Teóricas Indice[" + indice + "]");
string subject = "[" + indice + "] Atualização das Quantidades Teóricas";
string body = "E-Mail Automático gerado pelo Sistema Gradual.OMS.Cotacao - Servidor [" + System.Environment.MachineName + "]";
body += "\r\n";
body += "\r\n";
body += "Quantidades Teóricas atualizadas em " + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss");
body += "\r\n";
body += "\r\n";
body += "\r\n";
foreach (IndiceGradual.ItemComposicaoIndice item in lista)
{
body += String.Format("Ativo [{0,-14}] Qtd.Teórica [{1,12:######0.0000}]", item.ativo, item.qtdeTeorica);
body += "\r\n";
}
_enviarEmail(subject, body);
}
catch (Exception ex)
{
logger.Error("Falha em DivulgarQuantidadesTeoricas(): " + ex.Message);
}
}
private bool ProcessarQuantidadesTeoricas(string indice, string arquivo)
{
try
{
Dictionary <string, double> listaQtdTeoricas = new Dictionary <string, double>();
string linha;
StreamReader streamReader = new StreamReader(arquivo);
while ((linha = streamReader.ReadLine()) != null)
{
if (linha != null && linha.Trim().Length > 0)
{
string[] parametros = linha.Split('\t');
string ativo = parametros[0].Trim();
double qtdTeorica;
if (!double.TryParse(parametros[1].Replace(',', '.'), numberStyles, ciUS, out qtdTeorica))
{
qtdTeorica = 0;
}
if (ativo.Length > 0 && qtdTeorica > 0)
{
listaQtdTeoricas.Add(ativo, qtdTeorica);
}
}
}
streamReader.Close();
if (listaQtdTeoricas.Count == 0)
{
logger.Error("Não há linhas válidas no arquivo lido!");
return(false);
}
logger.Info("Atualizando Quantidades Teoricas");
DCotacoes _DCotacoes = new DCotacoes();
logger.Info("Ativos lidos e tratados do arquivo: " + listaQtdTeoricas.Count);
foreach (KeyValuePair <string, double> item in listaQtdTeoricas)
{
logger.Info("Gravando ComposicaoIndice Ativo[" + item.Key + "] QtdTeorica[" + item.Value + "]");
IndiceGradual.ItemComposicaoIndice itemComposicaoIndice = new IndiceGradual.ItemComposicaoIndice();
itemComposicaoIndice.ativo = item.Key;
itemComposicaoIndice.qtdeTeorica = item.Value;
itemComposicaoIndice.dataCotacao = DateTime.Now;
_DCotacoes.AtualizarComposicaoIndiceGradual(indice, itemComposicaoIndice, true);
}
}
catch (Exception ex)
{
logger.Error("Falha em ProcessarQuantidadesTeoricas(): " + ex.Message);
return(false);
}
return(true);
}
public void RecarregarComposicaoIndices()
{
try
{
if (CalcularIndiceGradual)
{
logger.Info("*** Carregando Composição dos Índices Gradual...");
listaIndice = new Dictionary <string, ItemIndice>();
listaComposicao = new Dictionary <string, List <ItemComposicaoIndice> >();
DCotacoes _DCotacoes = new DCotacoes();
List <ItemIndice> lista = _DCotacoes.ObterListaIndicesGradual();
foreach (ItemIndice item in lista)
{
logger.Info("Indice Gradual[" +
item.indice + "]: cod[" +
item.codigoIndice + "] cotacao[" +
item.cotacaoAtual + "] fechamento[" +
item.fechamentoAnterior + "] variacao[" +
item.variacao + "] data[" +
item.dataCotacao + "]");
listaIndice.Add(item.indice, item);
List <ItemComposicaoIndice> listaComposicaoIndice = _DCotacoes.ObterListaComposicaoIndiceGradual(item.codigoIndice);
logger.Info("Indice Gradual[" + item.indice + "] com " + listaComposicaoIndice.Count + " ativos carregados");
foreach (ItemComposicaoIndice itemComposicao in listaComposicaoIndice)
{
logger.Info("Indice Gradual[" +
item.indice + "]: ativo[" +
itemComposicao.ativo + "] qtdeTeorica[" +
itemComposicao.qtdeTeorica + "] data[" +
itemComposicao.dataCotacao + "]");
}
listaComposicao.Add(item.indice, listaComposicaoIndice);
}
logger.Info("*** Composição dos Índices carregados!");
}
}
catch (Exception ex)
{
logger.Error("RecarregarComposicaoIndices(): " + ex.Message, ex);
}
}
protected void ObterDadosPapel()
{
DCotacoes _DCotacoes = new DCotacoes();
Dictionary <string, string> papeisCadastro = _DCotacoes.ObterHashDadosCotacao();
foreach (KeyValuePair <string, string> item in papeisCadastro)
{
MemoriaCotacao.hstDadosPapel.AddOrUpdate(item.Key, item.Value, (key, oldvalue) => item.Value);
}
//Hashtable listaIndices = composicaoIndice.GetListaIndices();
foreach (string instrumento in papeisCadastro.Keys)
{
if (!MemoriaCotacao.hstCotacoes.ContainsKey(instrumento))
{
string fakemsg = "";
/*
* if (listaIndices.Contains(instrumento))
* {
* logger.Info("Inicializando dados de cotacao para indice [" + instrumento + "]");
*
* ComposicaoIndice.ItemIndice indice = (ComposicaoIndice.ItemIndice)listaIndices[instrumento];
*
* fakemsg = "NEBV"; // Tipo msg + bolsa
* fakemsg += "00000000000000000"; // Dthr
* fakemsg += instrumento.PadRight(20); // Instrumento
* fakemsg += indice.dataCotacao.ToString("yyyyMMdd");
* // Data
* fakemsg += indice.dataCotacao.ToString("HHmmss") + "000";
* // Hora
* fakemsg += "0".PadLeft(8, '0'); // Corretora compradora
* fakemsg += "0".PadLeft(8, '0'); // Corretora vendedora
* fakemsg += indice.valor.ToString("0.00", ciBR).PadLeft(13, '0');
* // Preco
* fakemsg += "0".PadLeft(12, '0'); // Quantidade
* fakemsg += "0".PadLeft(9, '0') + ",000"; // Max
* fakemsg += "0".PadLeft(9, '0') + ",000"; // Min
* fakemsg += "0".PadLeft(9, '0') + ",000"; // Volume
* fakemsg += "1".PadLeft(8, '0'); // Num Neg
* fakemsg += (indice.oscilacao < 0) ? "-" : " "; // Indic. Variacao
* fakemsg += Math.Abs(indice.oscilacao).ToString("0.00", ciBR).PadLeft(8, '0');
* // Variacao
* fakemsg += "2"; // "2" - negociado
* fakemsg += "0".PadLeft(12, '0'); // Qtde compra
* fakemsg += "0".PadLeft(12, '0'); // Qtde venda
* }
* else
* {
*/
logger.Info("Inicializando dados de cotacao para [" + instrumento + "]");
fakemsg = "NEB-"; // Tipo msg + bolsa
fakemsg += "00000000000000000"; // Dthr
fakemsg += instrumento.PadRight(20); // Instrumento
fakemsg += "0".PadLeft(8, '0'); // Data
fakemsg += "0".PadLeft(9, '0'); // Hora
fakemsg += "0".PadLeft(8, '0'); // Corretora compradora
fakemsg += "0".PadLeft(8, '0'); // Corretora vendedora
fakemsg += "0".PadLeft(9, '0') + ",000"; // Preco
fakemsg += "0".PadLeft(12, '0');
fakemsg += "0".PadLeft(9, '0') + ",000"; // Max
fakemsg += "0".PadLeft(9, '0') + ",000"; // Min
fakemsg += "0".PadLeft(9, '0') + ",000"; // Volume
fakemsg += "0".PadLeft(8, '0'); // Num Neg
fakemsg += " "; // Indic. Variacao
fakemsg += "0".PadLeft(5, '0') + ",00"; // Variacao
fakemsg += "0"; // "0" - nao negociado
fakemsg += "0".PadLeft(12, '0'); // Qtde compra
fakemsg += "0".PadLeft(12, '0'); // Qtde venda
fakemsg += "0".PadLeft(12, '0'); // Qtde negociada dia
fakemsg += "000000000,000"; // Preco medio
fakemsg += "000000000,000"; // Preco teorico abertura
fakemsg += " 00000.00"; // Variacao teorica
fakemsg += DateTime.MinValue.ToString("yyyyMMddHHmmss"); // Horario teorico abertura
//}
List <string> valores = MemoriaCotacao.hstCotacoes.GetOrAdd(instrumento, new List <string>());
valores.Add(fakemsg);
}
}
Dictionary <string, string> dadosOpcoes = _DCotacoes.ObterHashDadosOpcoes();
foreach (KeyValuePair <string, string> item in dadosOpcoes)
{
MemoriaCotacao.hstDadosOpcoes.AddOrUpdate(item.Key, item.Value, (key, oldvalue) => item.Value);
}
}
public void RecalcularIndice(string instrumento, string mensagem)
{
if (EfetuarCalculosIndice)
{
// Tratar apenas cotações existentes nos papéis dos Índices
if (hstPapeis.Contains(instrumento))
{
// Usar o índice IBOV para definir o momento do recarregamento de composição ou fechamento dos índices
if (instrumento.Equals(INDICE_IBOV))
{
string dataMsg = mensagem.Substring(41, 14);
DateTime dataCotacao = new DateTime(
int.Parse(dataMsg.Substring(0, 4)),
int.Parse(dataMsg.Substring(4, 2)),
int.Parse(dataMsg.Substring(6, 2)),
int.Parse(dataMsg.Substring(8, 2)),
int.Parse(dataMsg.Substring(10, 2)),
int.Parse(dataMsg.Substring(12, 2)));
int status = int.Parse(mensagem.Substring(155, 1));
// Se serviço ativado ou cotação já é do dia seguinte, recarrega a composição dos Índices
if (dataCotacaoIBOV.Equals(DateTime.MinValue) || dataCotacao.Date > dataCotacaoIBOV.Date)
{
statusIBOV = status;
dataCotacaoIBOV = dataCotacao;
logger.Info("Iniciando dia de negociações com dataCotação[" + dataCotacaoIBOV + "] e status[" + statusIBOV + "]");
RecarregarComposicaoIndices();
}
// Se cotação do IBOV não está mais em negociação, de um mesmo dia, grava fechamento dos Índices no SQL
else if (statusIBOV == 2 && status == 0 && dataCotacao.Date == dataCotacaoIBOV.Date)
{
statusIBOV = status;
DCotacoes _DCotacoes = new DCotacoes();
IDictionaryEnumerator itensIndice = hstIndices.GetEnumerator();
while (itensIndice.MoveNext())
{
logger.Info("Gravando Índice[" + ((ItemIndice)itensIndice.Value).indice + "] na tabela TB_ATIVO");
_DCotacoes.AtualizarTbAtivo((ItemIndice)itensIndice.Value);
logger.Info("Gravando Índice[" + ((ItemIndice)itensIndice.Value).indice + "] na tabela TB_HISTORICO_INDICE");
_DCotacoes.InserirTbHistoricoAtivo((ItemIndice)itensIndice.Value);
}
}
}
else
{
// Tratar apenas cotações de papéis em negociação
if (mensagem.Substring(155, 1).Equals("2"))
{
// Efetua o recálculo para todos os Índices onde o papel existe
foreach (string itemIndice in (List <string>)hstPapeis[instrumento])
{
double valorIndice = 0;
DateTime data = DateTime.Now;
foreach (ItemQtdeTeorica itemQtdeTeorica in (List <ItemQtdeTeorica>)hstComposicaoIndice[itemIndice])
{
if (itemQtdeTeorica.papel.Equals(instrumento))
{
string dataMsg = mensagem.Substring(41, 14);
data = new DateTime(
int.Parse(dataMsg.Substring(0, 4)),
int.Parse(dataMsg.Substring(4, 2)),
int.Parse(dataMsg.Substring(6, 2)),
int.Parse(dataMsg.Substring(8, 2)),
int.Parse(dataMsg.Substring(10, 2)),
int.Parse(dataMsg.Substring(12, 2)));
double valor = Convert.ToDouble(mensagem.Substring(74, 13), ciBR);
logger.Debug("Atualizando Cotação do papel[" + instrumento + "]: DataHora[" + data + "] valor[" + valor + "]");
itemQtdeTeorica.dataCotacao = data;
itemQtdeTeorica.valor = valor;
}
if (itemQtdeTeorica.dataCotacao.Date >= dataCotacaoIBOV.Date)
{
valorIndice += itemQtdeTeorica.qtdeTeorica * itemQtdeTeorica.valor;
logger.Debug("Acumula para papel[" + itemQtdeTeorica.papel + "] o valor [" + itemQtdeTeorica.valor + "]");
}
else
{
valorIndice += itemQtdeTeorica.qtdeTeorica * itemQtdeTeorica.fechamento;
logger.Debug("Acumula para papel[" + itemQtdeTeorica.papel + "] o fechamento[" + itemQtdeTeorica.fechamento + "]");
}
}
double oscilacao = 0;
double fechamento = ((ItemIndice)hstIndices[itemIndice]).fechamento;
if (fechamento != 0)
{
oscilacao = ((valorIndice / fechamento) - 1) * 100;
}
logger.Debug("Indice[" + itemIndice + "]: Valor[" + valorIndice + "] Oscilacao[" + oscilacao + "]");
string mensagemIndice = "NEBV"; // Tipo msg + bolsa
mensagemIndice += "00000000000000000"; // Dthr
mensagemIndice += itemIndice.PadRight(20); // Instrumento
mensagemIndice += mensagem.Substring(41, 8); // Data
mensagemIndice += mensagem.Substring(49, 9); // Hora
mensagemIndice += "0".PadLeft(8, '0'); // Corretora compradora
mensagemIndice += "0".PadLeft(8, '0'); // Corretora vendedora
mensagemIndice += valorIndice.ToString("0.00", ciBR).PadLeft(13, '0'); // Preco
mensagemIndice += "0".PadLeft(12, '0'); // Quantidade
mensagemIndice += "0".PadLeft(9, '0') + ",000"; // Max
mensagemIndice += "0".PadLeft(9, '0') + ",000"; // Min
mensagemIndice += "0".PadLeft(9, '0') + ",000"; // Volume
mensagemIndice += "1".PadLeft(8, '0'); // Num Neg
mensagemIndice += (oscilacao < 0) ? "-" : " "; // Indic. Variacao
mensagemIndice += Math.Abs(oscilacao).ToString("0.00", ciBR).PadLeft(8, '0'); // Variacao
mensagemIndice += "2"; // "2" - negociado
mensagemIndice += "0".PadLeft(12, '0'); // Qtde compra
mensagemIndice += "0".PadLeft(12, '0'); // Qtde venda
((ItemIndice)hstIndices[itemIndice]).valor = valorIndice;
((ItemIndice)hstIndices[itemIndice]).oscilacao = oscilacao;
((ItemIndice)hstIndices[itemIndice]).dataCotacao = data;
List <string> lstCotacoes;
lstCotacoes = MemoriaCotacao.hstCotacoes.GetOrAdd(itemIndice, new List <string>());
lstCotacoes.Add(mensagemIndice);
logger.Debug("Mensagem indice[" + mensagemIndice + "]");
//lock (MemoriaCotacao.hstCotacoes)
//{
// if (MemoriaCotacao.hstCotacoes[itemIndice] == null)
// {
// MemoriaCotacao.hstCotacoes.Add(itemIndice, new List<string>());
// }
// List<string> cotacoes = (List<string>)(MemoriaCotacao.hstCotacoes[itemIndice]);
// cotacoes.Add(mensagemIndice);
// logger.Debug("Mensagem indice[" + mensagemIndice + "]");
//}
}
}
}
}
}
}
public void RecarregarComposicaoIndices()
{
if (EfetuarCalculosIndice)
{
logger.Info("*** Carregando Composição dos Índices...");
DCotacoes _DCotacoes = new DCotacoes();
List <ItemIndice> listaIndice = _DCotacoes.ObterDadosIndice();
List <ItemComposicaoIndice> listaComposicaoIndice = _DCotacoes.ObterDadosComposicaoIndice();
hstIndices.Clear();
foreach (ItemIndice item in listaIndice)
{
hstIndices.Add(item.indice,
new ItemIndice(
item.indice,
item.codigoIndice,
item.fechamento,
item.fechamento,
item.oscilacao,
item.dataCotacao));
}
hstPapeis.Clear();
hstComposicaoIndice.Clear();
foreach (ItemComposicaoIndice item in listaComposicaoIndice)
{
if (!hstPapeis.Contains(item.papel))
{
List <string> listaNomeIndices = new List <string>();
listaNomeIndices.Add(item.indice);
hstPapeis.Add(item.papel, listaNomeIndices);
}
else
{
List <string> listaNomeIndices = (List <string>)hstPapeis[item.papel];
listaNomeIndices.Add(item.indice);
}
if (!hstComposicaoIndice.Contains(item.indice))
{
List <ItemQtdeTeorica> listaQtdeTeorica = new List <ItemQtdeTeorica>();
listaQtdeTeorica.Add(new ItemQtdeTeorica(item.papel, item.qtdeTeorica, item.valor, item.fechamento, item.dataCotacao));
hstComposicaoIndice.Add(item.indice, listaQtdeTeorica);
}
else
{
List <ItemQtdeTeorica> listaQtdeTeorica = (List <ItemQtdeTeorica>)hstComposicaoIndice[item.indice];
listaQtdeTeorica.Add(new ItemQtdeTeorica(item.papel, item.qtdeTeorica, item.valor, item.fechamento, item.dataCotacao));
}
}
hstPapeis.Add(INDICE_IBOV, null);
IDictionaryEnumerator itensIndice = hstIndices.GetEnumerator();
while (itensIndice.MoveNext())
{
logger.Info("Índice [" + itensIndice.Key + "]: fechamento[" + ((ItemIndice)itensIndice.Value).fechamento + "] dataCotacao[" + ((ItemIndice)itensIndice.Value).dataCotacao + "]");
}
IDictionaryEnumerator itens = hstComposicaoIndice.GetEnumerator();
while (itens.MoveNext())
{
logger.Info("Índice [" + itens.Key + "] contém [" + ((List <ItemQtdeTeorica>)itens.Value).Count + "] papéis");
foreach (ItemQtdeTeorica item in (List <ItemQtdeTeorica>)itens.Value)
{
logger.Info("Papel[" + item.papel + "] qtd teorica[" + item.qtdeTeorica + "] valor[" + item.valor + "] fechamento[" + item.fechamento + "] dataCotacao[" + item.dataCotacao + "]");
}
}
logger.Info("*** Composição dos Índices carregados!");
}
}
public void AtualizarIndiceGradual(string instrumento, string mensagem)
{
try
{
if (CalcularIndiceGradual)
{
DCotacoes _DCotacoes = new DCotacoes();
string dataHoraMensagem = mensagem.Substring(41, 14);
DateTime dataCotacao = new DateTime(
int.Parse(dataHoraMensagem.Substring(0, 4)),
int.Parse(dataHoraMensagem.Substring(4, 2)),
int.Parse(dataHoraMensagem.Substring(6, 2)),
int.Parse(dataHoraMensagem.Substring(8, 2)),
int.Parse(dataHoraMensagem.Substring(10, 2)),
int.Parse(dataHoraMensagem.Substring(12, 2)));
int status = int.Parse(mensagem.Substring(155, 1));
// Se serviço ativado ou cotação já é do dia seguinte, recarrega a composição dos Índices
if (dataCotacaoIBOV.Equals(DateTime.MinValue) || dataCotacao.Date > dataCotacaoIBOV.Date)
{
statusIBOV = 2;
dataCotacaoIBOV = dataCotacao;
logger.Info("Iniciando dia de negociações com dataCotação[" + dataCotacaoIBOV + "] e status[" + statusIBOV + "]");
RecarregarComposicaoIndices();
foreach (ItemIndice dadosIndice in listaIndice.Values)
{
dadosIndice.fechamentoAnterior = dadosIndice.cotacaoAtual;
logger.Info("Indice[" +
dadosIndice.indice + "]: Atualizando Fechamento Anterior[" +
dadosIndice.fechamentoAnterior + "] com a Cotação Atual[" +
dadosIndice.cotacaoAtual + "]");
}
}
// Se cotação do IBOV não está mais em negociação, de um mesmo dia, atualiza o fechamento dos Índices
else if (statusIBOV == 2 && status == 0 && dataCotacao.Date == dataCotacaoIBOV.Date)
{
foreach (ItemIndice dadosIndice in listaIndice.Values)
{
if (dataCotacao.Date == dadosIndice.dataCotacao)
{
dadosIndice.fechamentoAnterior = dadosIndice.cotacaoAtual;
_DCotacoes.AtualizarCotacaoIndice(dadosIndice);
logger.Info("Indice[" +
dadosIndice.indice + "]: Atualizado Fechamento Anterior[" +
dadosIndice.fechamentoAnterior + "] com a Cotação Atual[" +
dadosIndice.cotacaoAtual + "] variacao[" +
dadosIndice.variacao + "] data[" +
dadosIndice.dataCotacao + "]");
statusIBOV = status;
}
}
}
if (status == 2 && statusIBOV == 2)
{
foreach (ItemIndice dadosIndice in listaIndice.Values)
{
double valorIndice = 0;
bool gravarComposicaoIndice = true;
foreach (ItemComposicaoIndice item in listaComposicao[dadosIndice.indice])
{
lock (MemoriaCotacao.hstCotacoesIndiceGradual)
{
if (MemoriaCotacao.hstCotacoesIndiceGradual.ContainsKey(item.ativo))
{
string cotacao = (string)MemoriaCotacao.hstCotacoesIndiceGradual[item.ativo];
item.cotacao = Convert.ToDouble(cotacao.Substring(74, 13), ciBR);
string dataHora = cotacao.Substring(41, 14);
DateTime data = new DateTime(
int.Parse(dataHora.Substring(0, 4)),
int.Parse(dataHora.Substring(4, 2)),
int.Parse(dataHora.Substring(6, 2)),
int.Parse(dataHora.Substring(8, 2)),
int.Parse(dataHora.Substring(10, 2)),
int.Parse(dataHora.Substring(12, 2)));
if (item.cotacao == 0.0 || !DateTime.Now.ToString("yyyyMMdd").Equals(data.ToString("yyyyMMdd")))
{
logger.FatalFormat("Ativo [{0}] cotacao [{1}] ult neg [{2}] impedindo o calculo do indice",
item.ativo,
item.cotacao,
data.ToString("dd/MM/yyyy HH:mm:ss.fff"));
gravarComposicaoIndice = false;
break;
}
item.variacao = Convert.ToDouble(cotacao.Substring(146, 9).Trim(), ciBR);
item.qtdeAjustada = item.qtdeTeorica * item.cotacao;
valorIndice += item.qtdeAjustada;
item.dataCotacao = dataCotacao;
}
else
{
logger.FatalFormat("Ativo [{0}] sem cotacao na memoria, impedindo o calculo do indice", item.ativo);
gravarComposicaoIndice = false;
break;
}
}
}
// Apenas grava as atualizações de composição do indice e as atualizações do indice,
// se todas as cotações dos ativos estiverem com valor > 0 e tiverem cotações no dia corrente
if (gravarComposicaoIndice)
{
foreach (ItemComposicaoIndice item in listaComposicao[dadosIndice.indice])
{
_DCotacoes.AtualizarComposicaoIndiceGradual(dadosIndice.indice, item, false);
logger.Info("Gravado Composicao de Indice[" +
dadosIndice.indice + "]: ativo[" +
item.ativo + "]: cotacao[" +
item.cotacao + "] variacao[" +
item.variacao + "] qtdeAjustada[" +
item.qtdeAjustada + "] data[" +
item.dataCotacao + "]");
}
double variacao = 0;
double fechamento = dadosIndice.fechamentoAnterior;
if (fechamento != 0)
{
variacao = ((valorIndice / fechamento) - 1) * 100;
}
dadosIndice.cotacaoAtual = valorIndice;
dadosIndice.variacao = variacao;
dadosIndice.dataCotacao = dataCotacao;
_DCotacoes.AtualizarCotacaoIndice(dadosIndice);
logger.Info("Gravado Indice[" +
dadosIndice.indice + "]: cotacao[" +
dadosIndice.cotacaoAtual + "] fechamento[" +
dadosIndice.fechamentoAnterior + "] variacao[" +
dadosIndice.variacao + "] data[" +
dadosIndice.dataCotacao + "]");
if (EnviarPriceLinkBloomberg)
{
PriceLink.PriceLinkSession sessionPriceLink = new PriceLink.PriceLinkSession();
string indiceAtual = String.Format("{0:0.00}", dadosIndice.cotacaoAtual).Replace(",", ".");
sessionPriceLink.Contribute(
BloombergSecurityID,
indiceAtual,
BloombergTransactionType,
BloombergSecurityType,
BloombergSecurityIdType);
logger.Info("Enviado Bloomberg PriceLink SecurityID[" + BloombergSecurityID +
"]: cotacaoAtual[" + indiceAtual +
"] TransactionType[" + BloombergTransactionType +
"] SecurityType[" + BloombergSecurityType +
"] SecurityIdType[" + BloombergSecurityIdType + "]");
sessionPriceLink = null;
}
}
}
}
}
}
catch (Exception ex)
{
logger.Error("AtualizarIndiceGradual(): " + ex.Message, ex);
}
}
