Example #1
0
 public List <Moeda> FindAll()
 {
     using (var ctx = new CambioContext())
     {
         ctx.LazyLoading(false);
         var moedas = ctx.MoedaDao.FindAll();
         return(moedas);
     }
 }
Example #2
0
        /// <summary>
        /// Obtem a cotação das principais moedas referidas no sistema.
        /// </summary>
        /// <returns></returns>
        public CurrencyExchange GetCurrencyExchange()
        {
            CurrencyExchange cotacao = new CurrencyExchange();

            using (var ctx = new CambioContext())
            {
                DateTime data = DateTime.Now.ToDateZerada();

                if (data.DayOfWeek == DayOfWeek.Saturday)
                {
                    data = data.AddDays(-1);
                }
                else if (data.DayOfWeek == DayOfWeek.Sunday)
                {
                    data = data.AddDays(-2);
                }

                //localize as cotações do dia
                var cotExist = ctx.CotacaoMonetariaDao
                               .Where(c => c.DataCotacao.ToDateZerada() == data)
                               .ToList();

                if (cotExist.Count >= 9)
                {
                    //localizei primeiro a cotação no banco
                    //isso aqui eh mais rapido q obter da internet
                    cotacao.Cotacoes.AddRange(cotExist);
                }
                else
                {
                    var moedas = ctx.MoedaDao.FindAll();

                    foreach (var m in moedas)
                    {
                        try
                        {
                            //obtem do webservice mesmo
                            //persiste a cotação
                            CotacaoMonetaria cotNew = getCotacao((TypeCodigoBacen)m.CodigoWSCompra,
                                                                 (TypeCodigoBacen)m.CodigoWSVenda);

                            //sempre add
                            cotacao.AddCurrencyExchange(cotNew);

                            SaveCotacaoMonetaria(ctx, cotNew);
                        }
                        catch (Exception ex)
                        {
                            LoggerUtilIts.GenerateLogs(ex, "Falha no WSBacenCambio", "Falha na cotação cambial.");
                        }
                    }
                }
            }
            return(cotacao);
        }
Example #3
0
        /// <summary>
        /// Salva ou atualiza cotação
        /// </summary>
        /// <param name="ctx"></param> Contexto
        /// <param name="cot"></param>Cotação a ser salva
        private void SaveCotacaoMonetaria(CambioContext ctx, CotacaoMonetaria cotacao)
        {
            //use o codigo de compra mesmo
            long codigo = cotacao.Moeda.CodigoWSCompra;

            try
            {
                //recupera a moeda pelo codigo de compra/venda
                Moeda moeda = cotacao.Moeda;

                if (moeda == null || moeda.IdMoeda == 0)
                {
                    moeda = ctx.MoedaDao.First(m =>
                                               m.CodigoWSCompra == codigo ||
                                               m.CodigoWSVenda == codigo);
                }

                try
                {
                    //recupera a cotação
                    var current = ctx.CotacaoMonetariaDao
                                  .First(c => c.DataCotacao.Date == cotacao.DataCotacao &&
                                         c.IdMoeda == moeda.IdMoeda);

                    //e atualiza ela
                    current.ValorCompra = cotacao.ValorCompra;
                    current.ValorVenda  = cotacao.ValorVenda;
                    current.DataCotacao = cotacao.DataCotacao;
                    //atualiza no banco
                    ctx.CotacaoMonetariaDao.Update(current);
                }
                catch (Exception ex)
                {
                    //nao tem cotação add
                    Console.WriteLine("Criando um nova cotação: =>" + ex.Message);

                    //FK
                    cotacao.IdMoeda = moeda.IdMoeda;
                    //salva no banco
                    ctx.CotacaoMonetariaDao.Save(cotacao);
                }
            }
            catch (Exception ex)
            {
                string msg   = "Moeda não foi localizada";
                string title = "Problema na rotina de atualização cambial";
                XMessageIts.Advertencia(msg, title);

                LoggerUtilIts.GenerateLogs(ex, msg + "\n" + title);
            }
        }
Example #4
0
        private async void barBtnRefresh_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            using (var ctx = new CambioContext())
            {
                ctx.LazyLoading(false);
                var moedas = await ctx.MoedaDao.FindAllAsync();

                cbMoedas.AddList <Moeda>(moedas);
                //cbMoedas.BeginInvoke(new Action(()=>{
                //    cbMoedas.AddList<Moeda>(moedas);

                //}));
            }
        }
Example #5
0
        public Moeda GetMoedaByCodigo(long codigo)
        {
            using (var ctx = new CambioContext())
            {
                ctx.LazyLoading(false);
                try
                {
                    //recupera a moeda pelo codigo de compra/venda
                    var moeda = ctx.MoedaDao.First(m =>
                                                   m.CodigoWSCompra == codigo ||
                                                   m.CodigoWSVenda == codigo);

                    return(moeda);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }
Example #6
0
        public List <CotacaoMonetaria> GetCotacoesIndicadoresBacen()
        {
            var cotacoes = new List <CotacaoMonetaria>();

            using (var ctx = new CambioContext())
            {
                try
                {
                    //recupera as moedas
                    var indicadores = CambioContext.Instance.IndicadoresBacenDao
                                      .FindAll().ToList();
                    //.Where(m => m.NomeCompletoMoeda.ToLower().Contains("peso")).ToList();

                    foreach (var ind in indicadores)
                    {
                        try
                        {
                            var cot     = getLastCotacaoAux(ind.CodigoMoeda);
                            var cotacao = new CotacaoMonetaria(cot.DataCotacao, cot.ValorCotacao, cot.ValorCotacao, ind);
                            cotacoes.Add(cotacao);
                        }
                        catch (BacenCambioException ex)
                        {
                            XMessageIts.Erro("Falha ao informações dos indicadores\n\n" +
                                             "Erro:" + ex.Message, ex.Title);
                            return(null);
                        }
                    }
                }
                catch (Exception ex)
                {
                    string msg   = "Nenhum indicador localizado";
                    string title = "Falha na listagem de indicadores.";
                    XMessageIts.Advertencia(msg, title);
                    LoggerUtilIts.GenerateLogs(ex, msg + "\n" + title);
                }
            }
            return(cotacoes);
        }
Example #7
0
        private CotacaoMonetaria getCotacao(TypeCodigoBacen codigoCompra, TypeCodigoBacen codigoVenda)
        {
            long codCompra = (long)codigoCompra;
            long codVenda  = (long)codigoVenda;

            var cotCompraAux = getLastCotacaoAux(codCompra);
            var cotVendaAux  = getLastCotacaoAux(codVenda);

            //a data do cotCompraAux e cotVendaAux sao iguais
            var cot = new CotacaoMonetaria(cotVendaAux.DataCotacao, cotCompraAux.ValorCotacao,
                                           cotVendaAux.ValorCotacao, cotCompraAux.SerieVo);

            cot.AddReference(cotCompraAux.SerieVo);

            using (var ctx = new CambioContext())
            {
                try
                {
                    //recupera a moeda pelo codigo de compra/venda
                    Moeda moeda = ctx.MoedaDao.First(m =>
                                                     m.CodigoWSCompra == codCompra || m.CodigoWSVenda == codVenda);

                    cot.Moeda = moeda;
                    SaveCotacaoMonetaria(ctx, cot);
                }
                catch (Exception ex)
                {
                    string msg   = "Moeda não foi localizada";
                    string title = "Não foi possível obter a atualização cambial";
                    XMessageIts.Advertencia(msg, title);

                    LoggerUtilIts.GenerateLogs(ex, msg + "\n" + title);

                    throw ex;
                }
            }
            return(cot);
        }
Example #8
0
        /// <summary>
        /// Salva ou atualiza cotação
        /// </summary>
        /// <param name="ctx"></param> Contexto
        /// <param name="cot"></param>Cotação a ser salva
        public void SaveCotacaoMonetaria(CotacaoMonetaria cot)
        {
            using (var ctx = new CambioContext())
            {
                try
                {
                    var cotacao = new CotacaoMonetaria(cot.DataCotacao, cot.ValorCompra, cot.ValorVenda);
                    //FK
                    cotacao.IdMoeda = cot.Moeda.IdMoeda;

                    //salva no banco
                    ctx.CotacaoMonetariaDao.Save(cotacao);
                }
                catch (Exception ex)
                {
                    string msg   = "Moeda não foi localizada";
                    string title = "Problema na rotina de atualização cambial";
                    XMessageIts.Advertencia(msg, title);

                    LoggerUtilIts.GenerateLogs(ex, msg + "\n" + title);
                }
            }
        }
Example #9
0
        /// <summary>
        /// Cria um contexto
        /// </summary>
        /// <returns></returns>O Contexto
        private BalcaoContext createCtx()
        {
            try
            {
                //retorna o pai
                this._ctx = new BalcaoContext();

                using (var ctxIts = new ITSolutionContext())
                {
                    ctxIts.LazyLoading(false);
                    ctxIts.LembreteDao.Find(1);
                }


                //apenas invoca o mesmo para criação das tabelas
                using (var ctxRpt = new ReportContext())
                {
                    ctxRpt.LazyLoading(false);
                    ctxRpt.ReportGroupDao.Find(1);
                }

                using (var ctxCambio = new CambioContext())
                {
                    ctxCambio.LazyLoading(false);
                    ctxCambio.MoedaDao.Find(1);
                }
            }
            catch (Exception ex)
            {
                XMessageIts.ExceptionJustMessage(ex, "Falha na inicialização do controlador do contexto!", "Falha no Sistema");
                Application.Exit();
                Environment.Exit(0);
            }

            return(_ctx);
        }
Example #10
0
        private void loadCurrencyExchange()
        {
            string currencyName  = "";
            string currencyValue = "";
            var    o             = cbMoedas.SelectedItem as Moeda;
            var    sb            = new StringBuilder();

            pictureBoxProgress.BeginInvoke(new Action(() =>
            {
                pictureBoxProgress.Visible = true;
            }));

            if (o != null && o.CodigoWSVenda != 0)
            {
                sb.Append("COTAÇÃO MOEDA: ");
                sb.Append(o.NomeMoeda);
                sb.Append(" | ");
                sb.Append(DateTime.Now.ToShortDateString());

                if (_custeio == null)
                {
                    try
                    {
                        using (var ws = new WSBacenCambio())
                        {
                            var cot = ws.GetCotacaoByCodigo((TypeCodigoBacen)o.CodigoWSVenda);
                            cot.Moeda = o;
                            //pode lançar exceção
                            if (cot == null)
                            {
                                cot = new CambioContext().CotacaoMonetariaDao.Last();
                            }
                            this.cotacaoMonetaria = cot;
                            sb.Append(" | ");
                            sb.Append(cot.Fonte);

                            if (radioGroupCotacao.SelectedIndex == 1)
                            {
                                currencyValue = cot.ValorVenda.ToString("N4");
                                sb.Append(" | VENDA");
                                sb.Append(" : ");
                            }

                            else
                            {
                                currencyValue = cot.ValorCompra.ToString("N4");
                                sb.Append(" | COMPRA");
                                sb.Append(" : ");
                            }
                            sb.Append(currencyValue);

                            //termina a string
                            currencyName = sb.ToString();
                        }
                    }
                    catch (Exception exception)
                    {
                        XMessageIts.ExceptionMessageDetails(exception, "Falha na moeda");
                        currencyName  = "COTAÇÃO NÃO DISPONIVÉL";
                        currencyValue = "0,00";
                    }
                } //se os valores da ci
                else
                {
                    currencyValue = _custeio.ValorMoedaReais.ToString("n2");

                    sb.Append(" : ");
                    sb.Append(currencyValue);
                    //termina a string
                    currencyName = sb.ToString();
                }

                this.Invoke(new MethodInvoker(delegate
                {
                    lblMoedaName.Text          = currencyName;
                    textEditCotacaoMoeda.Text  = currencyValue;
                    pictureBoxProgress.Visible = false;
                }));
                //lblMoedaName.BeginInvoke(new Action(() =>
                //{
                //    lblMoedaName.Text = currencyName;
                //}));

                //textEditCotacaoMoeda.BeginInvoke(new Action(() =>
                //{
                //    textEditCotacaoMoeda.Text = currencyValue;
                //}));

                //pictureBoxProgress.BeginInvoke(new Action(() =>
                //{
                //    pictureBoxProgress.Visible = true;
                //}));
            }
        }