LevelOS-Core/DAL/DALLContasReceber.cs

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

namespace DAL
{
    public class DALLContasReceber
    {
        private readonly string connectionString;

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

        #region CRUD

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

                string sql = @"
                INSERT INTO ContasReceber
                (
                    EmpresaId,
                    ClienteId,
                    PlanoContaId,
                    ContratoId,
                    Descricao,
                    Valor,
                    DataEmissao,
                    DataVencimento,
                    DataPagamento,
                    Status,
                    ValorPago,
                    Juros,
                    Multa,
                    Desconto,
                    Observacoes,
                    Ativo,
                    CriadoEm,
                    AtualizadoEm
                )
                VALUES
                (
                    @EmpresaId,
                    @ClienteId,
                    @PlanoContaId,
                    @ContratoId,
                    @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(ModeloContaReceber modelo)
        {
            try
            {
                using SqlConnection conn = new(connectionString);

                string sql = @"
                UPDATE ContasReceber
                SET
                    EmpresaId = @EmpresaId,
                    ClienteId = @ClienteId,
                    PlanoContaId = @PlanoContaId,
                    ContratoId = @ContratoId,
                    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 ContasReceber
                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 ModeloContaReceber? Carregar(int id)
        {
            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM ContasReceber
            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;
        }//ObterOuCarregar

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

            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM ContasReceber
            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<ModeloContaReceber> ListarPendentes()
        {
            return ExecutarLista(
                "SELECT * FROM ContasReceber WHERE Status='Pendente'");
        }//ListarPendentes

        public List<ModeloContaReceber> ListarRecebidas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasReceber WHERE Status='Recebido'");
        }//ListarRecebidas

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

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

        public List<ModeloContaReceber> ListarInativas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasReceber WHERE Ativo=0");
        }//ListarInativas
        public List<ModeloContaReceber> ListarPorCliente(int clienteId)
        {
            return ExecutarLista(
                $"SELECT * FROM ContasReceber WHERE ClienteId={clienteId}");
        }//ListarPorCliente
        public List<ModeloContaReceber> ListarPorPlanoConta(int planoContaId)
        {
            return ExecutarLista(
                $"SELECT * FROM ContasReceber WHERE PlanoContaId={planoContaId}");
        }//ListarPorPlanoConta
        public List<ModeloContaReceber> ListarPorContrato(int contratoId)
        {
            return ExecutarLista(
                $"SELECT * FROM ContasReceber WHERE ContratoId={contratoId}");
        }//ListarPorContrato
        public List<ModeloContaReceber> ListarPorPeriodo(DateTime inicio, DateTime fim)
        {
            return ExecutarLista(
                $"SELECT * FROM ContasReceber WHERE DataVencimento BETWEEN '{inicio:yyyy-MM-dd}' AND '{fim:yyyy-MM-dd}'");
        }//ListarPorPeriodo
        public List<ModeloContaReceber> ListarPorStatus(string status)
        {
            return ExecutarLista(
                $"SELECT * FROM ContasReceber WHERE Status='{status}'");
        }//ListarPorStatus
        public List<ModeloContaReceber> ListarTodas()
        {
            return ExecutarLista(
                "SELECT * FROM ContasReceber");
        }//ListarTodas

        #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='Recebido' THEN 1 ELSE 0 END) AS RECEBIDAS,
                SUM(CASE WHEN DataVencimento < GETDATE()
                    AND Status <> 'Recebido'
                    THEN 1 ELSE 0 END) AS VENCIDAS,
                SUM(Valor) AS TOTAL_VALOR,
                SUM(ISNULL(ValorPago,0)) AS TOTAL_RECEBIDO
            FROM ContasReceber";

            using SqlCommand cmd =
                new(sql, conn);

            using SqlDataAdapter da =
                new(cmd);

            DataTable dt = new();

            da.Fill(dt);

            return dt;
        }

        #endregion

        #region HELPERS

        private List<ModeloContaReceber> ExecutarLista(
            string sql)
        {
            List<ModeloContaReceber> 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;
        }

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

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

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

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

                ContratoId =
                    dr["ContratoId"] == DBNull.Value
                    ? null
                    : Convert.ToInt32(
                        dr["ContratoId"]),

                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,
            ModeloContaReceber modelo)
        {
            cmd.Parameters.AddWithValue(
                "@EmpresaId",
                modelo.EmpresaId);

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

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

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

            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
    }
}