LevelOS-Core/DAL/DALLContasPagar.cs

using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;

namespace DALL
{
    public class DALLContasPagar
    {
        private readonly string connectionString;

        public DALLContasPagar(string conexao)
        {
            connectionString = conexao;
        }

        #region CRUD

        public bool Inserir(ModeloContaPagar modelo)
        {
            try
            {
                using SqlConnection conn = new(connectionString);

                string sql = @"
                INSERT INTO ContasPagar
                (
                    EmpresaId,
                    FornecedorId,
                    PlanoContaId,
                    Descricao,
                    Valor,
                    DataEmissao,
                    DataVencimento,
                    DataPagamento,
                    Status,
                    ValorPago,
                    Juros,
                    Multa,
                    Desconto,
                    Observacoes,
                    Ativo,
                    CriadoEm,
                    AtualizadoEm
                )
                VALUES
                (
                    @EmpresaId,
                    @FornecedorId,
                    @PlanoContaId,
                    @Descricao,
                    @Valor,
                    @DataEmissao,
                    @DataVencimento,
                    @DataPagamento,
                    @Status,
                    @ValorPago,
                    @Juros,
                    @Multa,
                    @Desconto,
                    @Observacoes,
                    @Ativo,
                    @CriadoEm,
                    @AtualizadoEm
                )";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametros(cmd, modelo);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }//Inserir

        public bool Alterar(ModeloContaPagar modelo)
        {
            try
            {
                using SqlConnection conn = new(connectionString);

                string sql = @"
                UPDATE ContasPagar
                SET
                    EmpresaId = @EmpresaId,
                    FornecedorId = @FornecedorId,
                    PlanoContaId = @PlanoContaId,
                    Descricao = @Descricao,
                    Valor = @Valor,
                    DataEmissao = @DataEmissao,
                    DataVencimento = @DataVencimento,
                    DataPagamento = @DataPagamento,
                    Status = @Status,
                    ValorPago = @ValorPago,
                    Juros = @Juros,
                    Multa = @Multa,
                    Desconto = @Desconto,
                    Observacoes = @Observacoes,
                    Ativo = @Ativo,
                    AtualizadoEm = @AtualizadoEm
                WHERE Id = @Id";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametros(cmd, modelo);

                cmd.Parameters.AddWithValue(
                    "@Id",
                    modelo.Id);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }//Alterar

        public bool Excluir(int id)
        {
            try
            {
                using SqlConnection conn =
                    new(connectionString);

                string sql = @"
                DELETE FROM ContasPagar
                WHERE Id = @Id";

                using SqlCommand cmd =
                    new(sql, conn);

                cmd.Parameters.AddWithValue(
                    "@Id",
                    id);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }//Excluir

        public ModeloContaPagar? Carregar(int id)
        {
            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM ContasPagar
            WHERE Id = @Id";

            using SqlCommand cmd =
                new(sql, conn);

            cmd.Parameters.AddWithValue(
                "@Id",
                id);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            if (dr.Read())
            {
                return PreencherModelo(dr);
            }

            return null;
        }//Obter

        public List<ModeloContaPagar> Listar()
        {
            List<ModeloContaPagar> lista = [];

            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM ContasPagar
            ORDER BY DataVencimento";

            using SqlCommand cmd =
                new(sql, conn);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }

            return lista;
        }//Listar

        #endregion

        #region VIEWS

        public List<ModeloContaPagar> ListarPendentes()
        {
            return ExecutarLista(
                "SELECT * FROM ContasPagar WHERE Status='Pendente'");
        }//ListarPendentes

        public List<ModeloContaPagar> ListarPagas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasPagar WHERE Status='Pago'");
        }//ListarPagas

        public List<ModeloContaPagar> ListarVencidas()
        {
            return ExecutarLista(@"
            SELECT *
            FROM ContasPagar
            WHERE
                DataVencimento < GETDATE()
                AND Status <> 'Pago'");
        }//ListarVencidas

        public List<ModeloContaPagar> ListarAtivas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasPagar WHERE Ativo=1");
        }//ListarAtivas

        public List<ModeloContaPagar> ListarInativas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasPagar WHERE Ativo=0");
        }//ListarInativas

        #endregion

        #region DASHBOARD

        public DataTable Dashboard()
        {
            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT
                COUNT(*) AS TOTAL,
                SUM(CASE WHEN Status='Pendente' THEN 1 ELSE 0 END) AS PENDENTES,
                SUM(CASE WHEN Status='Pago' THEN 1 ELSE 0 END) AS PAGAS,
                SUM(CASE WHEN DataVencimento < GETDATE()
                    AND Status <> 'Pago'
                    THEN 1 ELSE 0 END) AS VENCIDAS,
                SUM(Valor) AS TOTAL_VALOR,
                SUM(ISNULL(ValorPago,0)) AS TOTAL_PAGO
            FROM ContasPagar";

            using SqlCommand cmd =
                new(sql, conn);

            using SqlDataAdapter da =
                new(cmd);

            DataTable dt = new();

            da.Fill(dt);

            return dt;
        }//Dashboard

        #endregion

        #region HELPERS

        private List<ModeloContaPagar> ExecutarLista(
            string sql)
        {
            List<ModeloContaPagar> lista = [];

            using SqlConnection conn =
                new(connectionString);

            using SqlCommand cmd =
                new(sql, conn);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }

            return lista;
        }//ExecutarLista

        private static ModeloContaPagar PreencherModelo(
            SqlDataReader dr)
        {
            return new ModeloContaPagar
            {
                Id =
                    Convert.ToInt32(
                        dr["Id"]),

                EmpresaId =
                    Convert.ToInt32(
                        dr["EmpresaId"]),

                FornecedorId =
                    Convert.ToInt32(
                        dr["FornecedorId"]),

                PlanoContaId =
                    Convert.ToInt32(
                        dr["PlanoContaId"]),

                Descricao =
                    Convert.ToString(
                        dr["Descricao"])
                    ?? string.Empty,

                Valor =
                    Convert.ToDecimal(
                        dr["Valor"]),

                ValorPago =
                    dr["ValorPago"] == DBNull.Value
                    ? null
                    : Convert.ToDecimal(
                        dr["ValorPago"]),

                Juros =
                    Convert.ToDecimal(
                        dr["Juros"]),

                Multa =
                    Convert.ToDecimal(
                        dr["Multa"]),

                Desconto =
                    Convert.ToDecimal(
                        dr["Desconto"]),

                Status =
                    Convert.ToString(
                        dr["Status"])
                    ?? string.Empty,

                DataEmissao =
                    dr["DataEmissao"] == DBNull.Value
                    ? null
                    : Convert.ToDateTime(
                        dr["DataEmissao"]),

                DataVencimento =
                    Convert.ToDateTime(
                        dr["DataVencimento"]),

                DataPagamento =
                    dr["DataPagamento"] == DBNull.Value
                    ? null
                    : Convert.ToDateTime(
                        dr["DataPagamento"]),

                Observacoes =
                    Convert.ToString(
                        dr["Observacoes"])
                    ?? string.Empty,

                Ativo =
                    Convert.ToBoolean(
                        dr["Ativo"]),

                CriadoEm =
                    Convert.ToDateTime(
                        dr["CriadoEm"]),

                AtualizadoEm =
                    Convert.ToDateTime(
                        dr["AtualizadoEm"])
            };
        }

        private static void PreencherParametros(
            SqlCommand cmd,
            ModeloContaPagar modelo)
        {
            cmd.Parameters.AddWithValue(
                "@EmpresaId",
                modelo.EmpresaId);

            cmd.Parameters.AddWithValue(
                "@FornecedorId",
                modelo.FornecedorId);

            cmd.Parameters.AddWithValue(
                "@PlanoContaId",
                modelo.PlanoContaId);

            cmd.Parameters.AddWithValue(
                "@Descricao",
                string.IsNullOrWhiteSpace(
                    modelo.Descricao)
                ? DBNull.Value
                : modelo.Descricao);

            cmd.Parameters.AddWithValue(
                "@Valor",
                modelo.Valor);

            cmd.Parameters.AddWithValue(
                "@DataEmissao",
                modelo.DataEmissao.HasValue
                ? modelo.DataEmissao.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@DataVencimento",
                modelo.DataVencimento);

            cmd.Parameters.AddWithValue(
                "@DataPagamento",
                modelo.DataPagamento.HasValue
                ? modelo.DataPagamento.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@Status",
                modelo.Status);

            cmd.Parameters.AddWithValue(
                "@ValorPago",
                modelo.ValorPago.HasValue
                ? modelo.ValorPago.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@Juros",
                modelo.Juros);

            cmd.Parameters.AddWithValue(
                "@Multa",
                modelo.Multa);

            cmd.Parameters.AddWithValue(
                "@Desconto",
                modelo.Desconto);

            cmd.Parameters.AddWithValue(
                "@Observacoes",
                string.IsNullOrWhiteSpace(
                    modelo.Observacoes)
                ? DBNull.Value
                : modelo.Observacoes);

            cmd.Parameters.AddWithValue(
                "@Ativo",
                modelo.Ativo);

            cmd.Parameters.AddWithValue(
                "@CriadoEm",
                modelo.CriadoEm);

            cmd.Parameters.AddWithValue(
                "@AtualizadoEm",
                modelo.AtualizadoEm);
        }

        #endregion
    }
}