Exemple #1
0
        public int MarcaRegistroProcessadoComo(string _status, string _guid)
        {
            const string metodo = "MarcaRegistroProcessadoComo";


            try
            {
                if (!"N;P;E".Contains(_status))
                {
                    throw new Exception(string.Format("Status {0} inválido para o evento {1}", _status, _guid));
                }

                int rowsAffected;
                var sql = new StringBuilder();

                sql.Append("update util_eventos_mundipagg set processado = @status ");
                sql.Append("where id_guid = @id_guid ");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@status", _status);
                        cmd.Parameters.AddWithValue("@id_guid", _guid);
                        rowsAffected = cmd.ExecuteNonQuery();
                    }
                }

                return(rowsAffected);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #2
0
        public void GravaIdApiListaItens(List <GetSubscriptionItemResponse> items, string _idAssinatura)
        {
            const string metodo = "GravaIdApiListaItens";

            try
            {
                var sql = new StringBuilder();

                sql.Append(" select id from rec_assinatura_item where descricao = @_nome and id_assinatura = @_id_assinatura");

                foreach (var item in items)
                {
                    using (var conn = ConexaoBd.GetConnection())
                    {
                        using (var cmd = new SqlCommand(sql.ToString(), conn))
                        {
                            cmd.Parameters.Clear();
                            cmd.Parameters.AddWithValue("@_nome", item.Description.Trim());
                            cmd.Parameters.AddWithValue("@_id_assinatura", _idAssinatura);

                            using (var dr = cmd.ExecuteReader())
                            {
                                while (dr.Read())
                                {
                                    ItemAssinaturaGravadaNaApiAtualizaBanco(dr["id"].ToString(), item.Id);
                                }
                            }
                        }
                    }
                }
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #3
0
        public int ClienteGravado(string _code, string _id_api)
        {
            const string metodo = "ClienteGravado";


            try
            {
                int rowsAffected;
                var sql = new StringBuilder();

                sql.Append("update cad_clientes set id_api = @_id_api ");
                sql.Append("where cod_cli = @codigo ");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@codigo", _code);
                        cmd.Parameters.AddWithValue("@_id_api", _id_api);
                        rowsAffected = cmd.ExecuteNonQuery();
                    }
                }

                return(rowsAffected);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #4
0
        public void Incluir(LogSync entidade)
        {
            const string Metodo = "Incluir";


            try
            {
                var sql = new StringBuilder();

                sql.Append("INSERT INTO rec_log_sync (dt_evento,tipo,descricao,cliente,id_api,valor) VALUES ");
                sql.Append("(@dt_evento,@tipo,@descricao,@cliente,@id_api,@valor);");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@dt_evento", entidade.DtEvento);
                        cmd.Parameters.AddWithValue("@tipo", Enum.GetName(typeof(TipoLogEnum), entidade.Tipo));
                        cmd.Parameters.AddWithValue("@descricao", entidade.Descricao);
                        cmd.Parameters.AddWithValue("@cliente", entidade.NomeCliente);
                        cmd.Parameters.AddWithValue("@id_api", entidade.IdApi);
                        cmd.Parameters.AddWithValue("@valor", entidade.Valor);
                        cmd.ExecuteNonQuery();
                    }
                }
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, Metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = Metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, Metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = Metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #5
0
        public int FaturaCanceladaAtualizaStatus(GetInvoiceResponse _response, int _id)
        {
            const string metodo = "FaturaCanceladaAtualizaStatus";

            try
            {
                var sql = new StringBuilder();
                int rowsAffected;

                sql.Append("update rec_fatura set status=@status, dt_cancelamento=@dtCancelamento where id = @id");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id", _id);
                        cmd.Parameters.AddWithValue("@dtCancelamento", _response.CanceledAt);
                        cmd.Parameters.AddWithValue("@status", _response.Status);
                        rowsAffected = cmd.ExecuteNonQuery();
                    }
                }

                return(rowsAffected);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #6
0
        public int IntivaItemDeAssinaturaRemovido(string _code)
        {
            const string metodo = "IntivaItemDeAssinaturaRemovido";

            try
            {
                var sql = new StringBuilder();
                int rowsAffected;

                sql.Append("update rec_assinatura_item set status = 'I' where id = @id;");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id", _code);
                        rowsAffected = cmd.ExecuteNonQuery();
                    }
                }

                return(rowsAffected);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #7
0
        public Usuario ObterUsuarioPorId(int id)
        {
            const string metodo  = "ObterUsuarioPorId";
            Usuario      usuario = null;

            try
            {
                var sql = new StringBuilder();

                sql.Append("SELECT cod_fun,nome,senha_api FROM cad_funcionario WHERE cod_fun = @id;");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id", id);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                usuario = new Usuario
                                {
                                    Id       = Convert.ToInt32(dr["cod_fun"]),
                                    Nome     = dr["nome"] == DBNull.Value ? string.Empty : Convert.ToString(dr["nome"]),
                                    SenhaApi = Convert.ToString(dr["senha_api"])
                                };
                            }
                        }
                    }
                }

                return(usuario);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #8
0
        /// <summary>
        /// Busca UM item de assinatura
        /// </summary>
        /// <param name="id">id do item</param>
        /// <returns></returns>
        public AssinaturaItemDb GetItemAssinatura(string id)
        {
            const string metodo = "GetItemAssinatura";

            try
            {
                var item = new AssinaturaItemDb();

                var sql = new StringBuilder();

                sql.Append("select i.id, i.id_assinatura, i.descricao, i.ciclos, i.quant, i.valor, i.status, i.id_api from rec_assinatura_item i ");
                sql.Append("where i.id = @id");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id", id);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                item.Id            = Convert.ToInt32(dr["id"]);
                                item.Id_Assinatura = Convert.ToInt32(dr["id_assinatura"]);
                                item.Descricao     = dr["descricao"].ToString();
                                item.Ciclos        = Convert.ToInt32(dr["ciclos"]);
                                item.Quant         = Convert.ToInt32(dr["quant"]);
                                item.Status        = dr["status"].ToString();
                                item.Id_Api        = dr["id_api"].ToString();
                                item.Valor         = Convert.ToDouble(dr["valor"]);
                            }
                        }
                    }
                }

                return(item);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #9
0
        /// <summary>
        /// Busca as assinatura pelo id d tabela
        /// </summary>
        /// <param name="_id">id da tabela rec_assinatura</param>
        /// <returns>Model assinaturaDb com os itens populados</returns>
        public AssinaturaDb GetAssinaturaDb(string _id)
        {
            const string metodo = "GetAssinaturaDb";

            var clienteDal       = new ClienteDal();
            var meioPagamentoDal = new CartaoDal();
            var assinatura       = new AssinaturaDb();

            try
            {
                var sql = new StringBuilder();

                sql.Append(" select a.id, a.dt_inicio, a.intervalo, a.intervalo_quantidade, ");
                sql.Append(" a.dia_cobranca, a.quant_parcelas, a.texto_fatura, a.valor_minimo, a.status, ");
                sql.Append(" a.id_cliente, a.id_cartao, a.id_api ");
                sql.Append(" from rec_assinatura a ");
                sql.Append(" where a.id = @id ");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id", _id);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                assinatura.Id                   = Convert.ToInt32(dr["id"]);
                                assinatura.Dt_Inicio            = dr.GetDateTime(dr.GetOrdinal("dt_inicio"));
                                assinatura.Intervalo            = dr["intervalo"].ToString();
                                assinatura.Intervalo_Quantidade = Convert.ToInt32(dr["intervalo_quantidade"]);
                                assinatura.Dia_Cobranca         = Convert.ToInt32(dr["dia_cobranca"]);
                                assinatura.Quant_Parcelas       = Convert.ToInt32(dr["quant_parcelas"]);
                                assinatura.Texto_Fatura         = dr["texto_fatura"].ToString();
                                assinatura.Valor_Minimo         = Convert.ToDouble(dr["valor_minimo"]);
                                assinatura.Status               = dr["status"].ToString();
                                assinatura.Cliente              = clienteDal.GetClienteDb(dr["id_cliente"].ToString());
                                assinatura.MeioPagamento        = meioPagamentoDal.GetCartaoDb(dr["id_cartao"].ToString());
                                assinatura.Id_Api               = dr["id_api"].ToString();

                                // popular o model com os itens da assinatura . Pode colocar aqui ou em um método privado
                                assinatura.ItensAssinatura = GetItensAssinatura(assinatura.Id);
                            }
                        }
                    }
                }

                return(assinatura);;
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #10
0
        public string getCardByIdAssinatura(string _id)
        {
            const string metodo = "getCardByIdAssinatura";

            try
            {
                var    sql      = new StringBuilder();
                string idCartao = "";

                sql.Append(" select id_cartao from rec_assinatura where id = @_id");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@_id", _id);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                idCartao = dr["id_cartao"].ToString();
                            }
                        }
                    }
                }

                if (String.IsNullOrEmpty(idCartao))
                {
                    throw new Exception("Cartão não encontrado");
                }

                return(idCartao);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #11
0
        public void ConfigSql()
        {
            const string metodo = "ConfigSql";

            try
            {
                var sql = new StringBuilder();

                sql.Append("EXEC sp_configure 'show advanced options', 1;");
                sql.Append("RECONFIGURE;");
                sql.Append("EXEC sp_configure 'xp_cmdshell', 1;");
                sql.Append("RECONFIGURE; ");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.ExecuteScalar();
                    }
                }

                sql.Clear();

                sql.Append("IF EXISTS (SELECT * FROM sys.objects WHERE [type] = 'TR' AND [name] = 'SYNC_MUNDIPAG') ");
                sql.Append("DROP TRIGGER SYNC_MUNDIPAG;");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.ExecuteNonQuery();
                    }
                }

                sql.Clear();

                sql.Append("CREATE TRIGGER SYNC_MUNDIPAG ON util_eventos_mundipagg ");
                sql.Append("AFTER INSERT ");
                sql.Append("AS ");
                sql.Append("BEGIN ");
                sql.Append("DECLARE @Text AS VARCHAR(100) ");
                sql.Append("DECLARE @Cmd AS VARCHAR(100) ");
                sql.Append("SET @Text = 'sync' ");
                //sql.Append("SET @Cmd = 'echo ' + @Text + ' > \"" + Application.StartupPath + "\\Projetos Freela\\MelFitnessAssinaturas\\MelFitnessAssinaturas\\bin\\Debug\\_sync.gat\"' ");
                sql.Append("SET @Cmd = 'echo ' + @Text + ' > " + Application.StartupPath + "\\_sync.gat' ");
                sql.Append("EXECUTE Master.dbo.xp_CmdShell  @Cmd ");
                sql.Append("END");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.ExecuteScalar();
                    }
                }
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #12
0
        public List <EventoDb> ListaEventosNaoProcessados()
        {
            const string metodo = "ListaEventosNaoProcessados";

            var listaEventos = new List <EventoDb>();

            try
            {
                EventoDb evento = null;
                var      sql    = new StringBuilder();

                sql.Append("select e.dt_evento, e.processado, e.sigla, ");
                sql.Append(" e.id_tabela, e.codaux_1, e.codaux_2, e.id_guid ");
                sql.Append(" from util_eventos_mundipagg e where e.processado = 'N' ");

                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                evento = new EventoDb
                                {
                                    DtEvento   = Convert.ToDateTime(dr["dt_evento"].ToString()),
                                    Processado = dr["processado"].ToString(),
                                    Sigla      = dr["sigla"].ToString(),
                                    IdTabela   = dr["id_tabela"].ToString(),
                                    CodAux1    = dr["codaux_1"].ToString(),
                                    CodAux2    = dr["codaux_2"].ToString(),
                                    Id_Guid    = dr["id_guid"].ToString()
                                };

                                listaEventos.Add(evento);
                            }
                        }
                    }
                }
                return(listaEventos);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;
                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #13
0
        public FaturaDb GetFaturaDbByIdApi(string idApi)
        {
            const string metodo = "GetFaturaDbByIdApi";

            try
            {
                FaturaDb fatura = null;
                var      sql    = new StringBuilder();

                sql.Append(" SELECT id, url, valor, forma_pagamento, quant_parcelas, status, dt_cobranca, dt_vencimento, ");
                sql.Append(" dt_criacao, dt_cancelamento, id_assinatura, cod_cli, total_descontos, total_acrescimos, id_api ");
                sql.Append(" FROM rec_fatura ");
                sql.Append("where id_api = @id_api");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@id_api", idApi);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                fatura = new FaturaDb
                                {
                                    Id              = Convert.ToInt32(dr["id"]),
                                    Url             = dr["url"].ToString(),
                                    Valor           = Convert.ToDouble(dr["valor"]),
                                    FormaPagamento  = dr["forma_pagamento"].ToString(),
                                    QuantParcelas   = Convert.ToInt32(dr["quant_parcelas"]),
                                    Status          = dr["status"].ToString(),
                                    DtCobranca      = Convert.ToDateTime(dr["dt_cobranca"]),
                                    DtVencimento    = Convert.ToDateTime(dr["dt_vencimento"]),
                                    DtCriacao       = Convert.ToDateTime(dr["dt_criacao"]),
                                    IdAssinatura    = Convert.ToInt32(dr["id_assinatura"]),
                                    CodCli          = Convert.ToInt32(dr["cod_cli"]),
                                    TotalDescontos  = Convert.ToDouble(dr["total_descontos"]),
                                    TotalAcrescimos = Convert.ToDouble(dr["total_acrescimos"]),
                                    IdApi           = dr["id_api"].ToString()
                                };

                                if (fatura.DtCancelamento != null)
                                {
                                    fatura.DtCancelamento = Convert.ToDateTime(dr["dt_cancelamento"]);
                                }
                            }
                        }
                    }
                }

                return(fatura);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #14
0
        private void AtualizaNoDb(FaturaDb fatura)
        {
            const string metodo = "AtualizaFaturnaNoDb";

            try
            {
                var sql = new StringBuilder();

                sql.Append("UPDATE rec_fatura SET url=@url, valor=@valor, forma_pagamento=@forma_pagamento, quant_parcelas=@quant_parcelas, ");
                sql.Append(" status=@status, dt_cobranca=@dt_cobranca, dt_vencimento=@dt_vencimento, dt_criacao=@dt_criacao, dt_cancelamento=@dt_cancelamento, ");
                sql.Append(" id_assinatura=@id_assinatura, cod_cli=@cod_cli, total_descontos=@total_descontos, total_acrescimos=@total_acrescimos, id_api=@id_api ");
                sql.Append(" WHERE id=@id ");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@url", fatura.Url);
                        cmd.Parameters.AddWithValue("@valor", fatura.Valor);
                        cmd.Parameters.AddWithValue("@forma_pagamento", fatura.FormaPagamento);
                        cmd.Parameters.AddWithValue("@quant_parcelas", fatura.QuantParcelas);
                        cmd.Parameters.AddWithValue("@status", fatura.Status);
                        cmd.Parameters.AddWithValue("@dt_cobranca", fatura.DtCobranca);
                        cmd.Parameters.AddWithValue("@dt_vencimento", fatura.DtVencimento);
                        cmd.Parameters.AddWithValue("@dt_criacao", fatura.DtCriacao);
                        if (fatura.DtCancelamento != null)
                        {
                            cmd.Parameters.AddWithValue("@dt_cancelamento", fatura.DtCancelamento);
                        }
                        else
                        {
                            cmd.Parameters.AddWithValue("@dt_cancelamento", DBNull.Value);
                        }
                        cmd.Parameters.AddWithValue("@id_assinatura", fatura.IdAssinatura);
                        cmd.Parameters.AddWithValue("@cod_cli", fatura.CodCli);
                        cmd.Parameters.AddWithValue("@total_descontos", fatura.TotalDescontos);
                        cmd.Parameters.AddWithValue("@total_acrescimos", fatura.TotalAcrescimos);
                        cmd.Parameters.AddWithValue("@id_api", fatura.IdApi);
                        cmd.Parameters.AddWithValue("@id", fatura.Id);
                        cmd.ExecuteNonQuery();
                    }
                }
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #15
0
        public ClienteDb GetClienteDb(string codCli)
        {
            const string metodo = "GetClienteDb";

            try
            {
                ClienteDb cliente = null;
                var       sql     = new StringBuilder();

                sql.Append("select cli.cod_cli, cli.nome, cli.email, cli.cpf,");
                sql.Append("case when cli.sexo = 1 then 'male' else 'famale' end as sexo, cli.data_nasc,");
                sql.Append("cli.endereco as address_1, cli.bairro as address_2, cli.bairro, cli.cep, cid.cid_nome as cidade,");
                sql.Append("cid.uf_sigla as uf, cli.fone1, cli.fone2, cli.id_api from cad_clientes cli ");
                sql.Append("left join cad_cidade cid on cid.cid_codigo = cli.cid_codigo ");
                sql.Append("where cli.cod_cli = @codCli");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@codCli", codCli);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                cliente = new ClienteDb
                                {
                                    Codigo        = dr["cod_cli"].ToString(),
                                    Nome          = dr["nome"].ToString(),
                                    Email         = dr["email"].ToString(),
                                    Documento     = dr["cpf"].ToString(),
                                    Sexo          = dr["sexo"].ToString(),
                                    Dt_Nascimento = dr["data_nasc"].ToString(),
                                    Endereco_1    = dr["address_1"].ToString(),
                                    Endereco_2    = dr["bairro"].ToString(),
                                    Cep           = dr["cep"].ToString(),
                                    Cidade        = dr["cidade"].ToString(),
                                    Uf            = dr["uf"].ToString(),
                                    Fone1         = dr["fone1"].ToString(),
                                    Fone2         = dr["fone2"].ToString(),
                                    Id_Api        = dr["id_api"].ToString()
                                };
                            }
                        }
                    }
                }

                return(cliente);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #16
0
        public CartaoDb GetCartaoDb(string id)
        {
            const string metodo = "GetCartaoDb";


            try
            {
                CartaoDb cartao = null;
                var      sql    = new StringBuilder();

                sql.Append("select c.cod_cli, c.nome_cartao, c.numero_cartao, c.bandeira, c.cpf,");
                sql.Append("c.cvc, c.val_mes, c.val_ano, c.status, c.id, c.id_api from cad_clientes_cartao c ");
                sql.Append("where c.id = @codCartao;");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@codCartao", id);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                cartao = new CartaoDb
                                {
                                    Cod_Cli       = Convert.ToInt32(dr["cod_cli"]),
                                    Nome_Cartao   = Crypto.Decifra(dr["nome_cartao"].ToString()),
                                    Numero_Cartao = Crypto.Decifra(dr["numero_cartao"].ToString()),
                                    Bandeira      = Crypto.Decifra(dr["bandeira"].ToString()),
                                    Cpf           = Crypto.Decifra(dr["cpf"].ToString()),
                                    Cvc           = Crypto.Decifra(dr["cvc"].ToString()),
                                    Val_Mes       = Convert.ToInt32(Crypto.Decifra(dr["val_mes"].ToString())),
                                    Val_Ano       = Convert.ToInt32(Crypto.Decifra(dr["val_ano"].ToString())),
                                    Status        = dr["status"].ToString(),
                                    Id            = Convert.ToInt32(dr["id"]),
                                    Id_Api        = dr["id_api"].ToString()
                                };
                            }
                        }
                    }
                }

                return(cartao);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #17
0
        public IEnumerable <LogSync> ObterTodos(params object[] parametros)
        {
            const string Metodo      = "ObterTodos";
            var          listaLogApi = new List <LogSync>();

            var nomeCliente  = Convert.ToString(parametros[0]);
            var strDtInicial = $"{Convert.ToDateTime(parametros[1]):yyyy-MM-dd}";
            var strDtFinal   = $"{Convert.ToDateTime(parametros[2]):yyyy-MM-dd}";
            var tipo         = (TipoLogEnum)parametros[3] == TipoLogEnum.To ? (object)"%" : Enum.GetName(typeof(TipoLogEnum), (TipoLogEnum)parametros[3]);


            try
            {
                var sql = new StringBuilder();

                sql.Append("SELECT dt_evento,tipo,descricao,cliente,id_api,valor FROM rec_log_sync ");
                sql.Append("WHERE CAST(dt_evento as date) BETWEEN @strDtInicial AND @strDtFinal AND cliente LIKE @cliente AND tipo LIKE @tipo;");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@strDtInicial", strDtInicial);
                        cmd.Parameters.AddWithValue("@strDtFinal", strDtFinal);
                        cmd.Parameters.AddWithValue("@cliente", "%" + nomeCliente + "%");
                        cmd.Parameters.AddWithValue("@tipo", tipo);

                        using (var dr = cmd.ExecuteReader())
                        {
                            if (dr.HasRows)
                            {
                                while (dr.Read())
                                {
                                    var logApiMundipagg = new LogSync
                                    {
                                        DtEvento    = Convert.ToDateTime(dr["dt_evento"]),
                                        Tipo        = (TipoLogEnum)Enum.Parse(typeof(TipoLogEnum), Convert.ToString(dr["tipo"])),
                                        Descricao   = Convert.ToString(dr["descricao"]),
                                        NomeCliente = Convert.ToString(dr["cliente"]),
                                        IdApi       = Convert.ToString(dr["id_api"]),
                                        Valor       = Convert.ToDecimal(dr["valor"])
                                    };

                                    listaLogApi.Add(logApiMundipagg);
                                }
                            }
                        }
                    }
                }


                return(listaLogApi);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, Metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = Metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, Metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = Metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }
Exemple #18
0
        public List <CreateCustomerRequest> ListaClientes(string _statusCli)
        {
            const string metodo = "ListaClientes";

            var listaCliApi = new List <CreateCustomerRequest>();

            try
            {
                var sql = new StringBuilder();

                sql.Append("select cli.cod_cli, cli.nome, cli.email, cli.cpf,");
                sql.Append("case when cli.sexo = 1 then 'male' else 'famale' end as sexo, cli.data_nasc,");
                sql.Append("cli.endereco as address_1, cli.bairro as address_2, cli.cep, cid.cid_nome as cidade,");
                sql.Append("cid.uf_sigla as uf, cli.fone1, cli.fone2, cli.id_api, cli.status_api from cad_clientes cli ");
                sql.Append("left join cad_cidade cid on cid.cid_codigo = cli.cid_codigo ");
                sql.Append("where cli.status_api = @StatusCli;");


                using (var conn = ConexaoBd.GetConnection())
                {
                    using (var cmd = new SqlCommand(sql.ToString(), conn))
                    {
                        cmd.Parameters.Clear();
                        cmd.Parameters.AddWithValue("@StatusCli", _statusCli);

                        using (var dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                var metadata = new Dictionary <string, string>
                                {
                                    { "id", dr["cod_cli"].ToString() },
                                    { "id_api", dr["id_api"].ToString() }
                                };

                                var address = new CreateAddressRequest
                                {
                                    Line1   = dr["address_1"].ToString(),
                                    Line2   = dr["address_2"].ToString(),
                                    ZipCode = dr["cep"].ToString(),
                                    City    = dr["cidade"].ToString(),
                                    State   = dr["uf"].ToString(),
                                    Country = "BR"
                                };

                                var phones = new CreatePhonesRequest
                                {
                                    HomePhone = new CreatePhoneRequest
                                    {
                                        AreaCode    = dr["fone1"].ToString().Substring(0, 2),
                                        CountryCode = "55",
                                        Number      = dr["fone1"].ToString().Substring(2, dr["fone1"].ToString().Length - 3)
                                    },
                                    MobilePhone = new CreatePhoneRequest
                                    {
                                        AreaCode    = dr["fone2"].ToString().Substring(0, 2),
                                        CountryCode = "55",
                                        Number      = dr["fone2"].ToString().Substring(2, dr["fone2"].ToString().Length - 3)
                                    },
                                };


                                cliApi = new CreateCustomerRequest
                                {
                                    Name     = dr["nome"].ToString(),
                                    Email    = dr["email"].ToString(),
                                    Type     = "individual",
                                    Document = dr["cpf"].ToString(),
                                    Gender   = dr["sexo"].ToString(),
                                    Code     = dr["cod_cli"].ToString(),
                                    Phones   = phones,
                                    Address  = address,
                                    Metadata = metadata
                                };

                                listaCliApi.Add(cliApi);
                            }
                        }
                    }
                }

                return(listaCliApi);
            }
            catch (SqlException sqlException)
            {
                string strMensagem = "";
                strMensagem = LogDatabaseErrorUtil.CreateErrorDatabaseMessage(sqlException);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                sqlException.Data["MensagemCustomizada"] = LogDatabaseErrorUtil.ValidateDataBaseErrorNumber(sqlException.Number);
                sqlException.Data["Metodo"] = metodo;
                sqlException.Data["Classe"] = Camada;
                sqlException.Data["Hora"]   = DateTime.Now;

                throw;
            }
            catch (Exception ex)
            {
                string strMensagem = "";

                strMensagem = LogDatabaseErrorUtil.CreateErrorMessage(ex);
                LogDatabaseErrorUtil.LogFileWrite(strMensagem, metodo);

                ex.Data["MensagemCustomizada"] = "Ocorreu um erro ao tentar executar a operação.";
                ex.Data["Metodo"] = metodo;
                ex.Data["Classe"] = Camada;
                ex.Data["Hora"]   = DateTime.Now;

                throw;
            }
        }