levelcode/LevelOS-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

27/05/2026 - Criando melhorias na DLL (DAL e UI)

Browse Source
This commit is contained in:
levelcode developed 2026-05-27 23:07:20 -03:00
parent 079532bf61
commit 8e15a24594
17 changed files with 6283 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

839
DAL/DALContas.cs Normal file
View File

@ -0,0 +1,839 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALContas
{
private readonly string connectionString;
public DALContas(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloContas modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Contas
(
TIPO,
CLIENTE,
FORNECEDOR,
COD_CLIENTE,
COD_FORNECEDOR,
VENCIMENTO,
PAGO,
PLANO_CONTAS,
OBSERVACAO,
VALOR,
REFERENCIA,
FCOBRANCA,
PARCELA,
ECF_DINHEIRO,
ECF_CHEQUE,
ECF_CARTAO,
ECF_BOLETO,
ECF_TROCO,
DATA_DOCTO,
JUROS,
DESCONTO,
CFOP,
CLISTSERV,
PMVAST,
PREDBCST,
VBCICMSST,
AICMSST,
VICMSST,
DATA_PGTO,
COD_CORRENTE,
OBS_COB
)
VALUES
(
@TIPO,
@CLIENTE,
@FORNECEDOR,
@COD_CLIENTE,
@COD_FORNECEDOR,
@VENCIMENTO,
@PAGO,
@PLANO_CONTAS,
@OBSERVACAO,
@VALOR,
@REFERENCIA,
@FCOBRANCA,
@PARCELA,
@ECF_DINHEIRO,
@ECF_CHEQUE,
@ECF_CARTAO,
@ECF_BOLETO,
@ECF_TROCO,
@DATA_DOCTO,
@JUROS,
@DESCONTO,
@CFOP,
@CLISTSERV,
@PMVAST,
@PREDBCST,
@VBCICMSST,
@AICMSST,
@VICMSST,
@DATA_PGTO,
@COD_CORRENTE,
@OBS_COB
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosInserir(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}//Inserir
public bool Alterar(ModeloContas modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contas
SET
CODIGO = @CODIGO,
TIPO = @TIPO,
CLIENTE = @CLIENTE,
FORNECEDOR = @FORNECEDOR,
COD_CLIENTE = @COD_CLIENTE,
COD_FORNECEDOR = @COD_FORNECEDOR,
VENCIMENTO = @VENCIMENTO,
PAGO = @PAGO,
PLANO_CONTAS = @PLANO_CONTAS,
OBSERVACAO = @OBSERVACAO,
VALOR = @VALOR,
REFERENCIA = @REFERENCIA,
FCOBRANCA = @FCOBRANCA,
PARCELA = @PARCELA,
ECF_DINHEIRO = @ECF_DINHEIRO,
ECF_CHEQUE = @ECF_CHEQUE,
ECF_CARTAO = @ECF_CARTAO,
ECF_BOLETO = @ECF_BOLETO,
ECF_TROCO = @ECF_TROCO,
DATA_DOCTO = @DATA_DOCTO,
JUROS = @JUROS,
DESCONTO = @DESCONTO,
CFOP = @CFOP,
CLISTSERV = @CLISTSERV,
PMVAST = @PMVAST,
PREDBCST = @PREDBCST,
VBCICMSST = @VBCICMSST,
AICMSST = @AICMSST,
VICMSST = @VICMSST,
DATA_PGTO = @DATA_PGTO,
COD_CORRENTE = @COD_CORRENTE,
OBS_COB = @OBS_COB
WHERE ID_CONTAS =
@ID_CONTAS";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosAlterar(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@ID_CONTAS",
modelo.ID_CONTAS);
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 Contas
WHERE ID_CONTAS =
@ID_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}//Excluir
public ModeloContas? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE ID_CONTAS =
@ID_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}//Carregar
public List<ModeloContas> Listar()
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//Listar
public List<ModeloContas> Listar(string valor)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE CLIENTE LIKE @VALOR
OR FORNECEDOR LIKE @VALOR
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@VALOR",
$"%{valor}%");
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorValores
public List<ModeloContas> ListarPorTipo(string tipo)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE TIPO = @TIPO
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@TIPO",
tipo);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorTipo
public List<ModeloContas> ListarPorCliente(string cliente)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE CLIENTE = @CLIENTE
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@CLIENTE",
cliente);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorCliente
public List<ModeloContas> ListarPorFornecedor(string fornecedor)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE FORNECEDOR = @FORNECEDOR
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@FORNECEDOR",
fornecedor);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorFornecedor
public List<ModeloContas> ListarPorPlanoContas(string planoContas)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PLANO_CONTAS = @PLANO_CONTAS
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PLANO_CONTAS",
planoContas);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorPlanoContas
public List<ModeloContas> ListarPorVencimento(string vencimento)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE VENCIMENTO = @VENCIMENTO
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@VENCIMENTO",
vencimento);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorVencimento
public List<ModeloContas> ListarPorPago(string pago)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PAGO = @PAGO
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PAGO",
pago);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorPago
public List<ModeloContas> ListarPorReferencia(string referencia)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE REFERENCIA = @REFERENCIA
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@REFERENCIA",
referencia);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorReferencia
public List<ModeloContas> ListarPorFCOBRANCA(string fCobranca)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE FCOBRANCA = @FCOBRANCA
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@FCOBRANCA",
fCobranca);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorFCOBRANCA
public List<ModeloContas> ListarPorParcela(string parcela)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PARCELA = @PARCELA
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PARCELA",
parcela);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorParcela
public List<ModeloContas> ListarPorPlanoContasECliente(string planoContas, string cliente)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PLANO_CONTAS = @PLANO_CONTAS
AND CLIENTE = @CLIENTE
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PLANO_CONTAS",
planoContas);
cmd.Parameters.AddWithValue(
"@CLIENTE",
cliente);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorPlanoContasECliente
public List<ModeloContas> ListarPorPlanoContasEFornecedor(string planoContas, string fornecedor)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PLANO_CONTAS = @PLANO_CONTAS
AND FORNECEDOR = @FORNECEDOR
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PLANO_CONTAS",
planoContas);
cmd.Parameters.AddWithValue(
"@FORNECEDOR",
fornecedor);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorPlanoContasEFornecedor
public List<ModeloContas> ListarPorPlanoContasEReferencia(string planoContas, string referencia)
{
List<ModeloContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas
WHERE PLANO_CONTAS = @PLANO_CONTAS
AND REFERENCIA = @REFERENCIA
ORDER BY ID_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@PLANO_CONTAS",
planoContas);
cmd.Parameters.AddWithValue(
"@REFERENCIA",
referencia);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}//ListarPorPlanoContasEReferencia
#endregion
#region HELPERS
private static ModeloContas PreencherModelo(
SqlDataReader dr)
{
return new ModeloContas
{
ID_CONTAS =
Convert.ToInt32(
dr["ID_CONTAS"]),
CODIGO =
Convert.ToString(
dr["CODIGO"])
?? string.Empty,
TIPO =
Convert.ToString(
dr["TIPO"])
?? string.Empty,
CLIENTE =
Convert.ToString(
dr["CLIENTE"])
?? string.Empty,
FORNECEDOR =
Convert.ToString(
dr["FORNECEDOR"])
?? string.Empty,
COD_CLIENTE =
Convert.ToString(
dr["COD_CLIENTE"])
?? string.Empty,
COD_FORNECEDOR =
Convert.ToString(
dr["COD_FORNECEDOR"])
?? string.Empty,
VENCIMENTO =
Convert.ToString(
dr["VENCIMENTO"])
?? string.Empty,
PAGO =
Convert.ToString(
dr["PAGO"])
?? string.Empty,
PLANO_CONTAS =
Convert.ToString(
dr["PLANO_CONTAS"])
?? string.Empty,
OBSERVACAO =
Convert.ToString(
dr["OBSERVACAO"])
?? string.Empty,
VALOR =
Convert.ToString(
dr["VALOR"])
?? string.Empty,
REFERENCIA =
Convert.ToString(
dr["REFERENCIA"])
?? string.Empty,
FCOBRANCA =
Convert.ToString(
dr["FCOBRANCA"])
?? string.Empty,
PARCELA =
Convert.ToString(
dr["PARCELA"])
?? string.Empty,
ECF_DINHEIRO =
Convert.ToString(
dr["ECF_DINHEIRO"])
?? string.Empty,
ECF_CHEQUE =
Convert.ToString(
dr["ECF_CHEQUE"])
?? string.Empty,
ECF_CARTAO =
Convert.ToString(
dr["ECF_CARTAO"])
?? string.Empty,
ECF_BOLETO =
Convert.ToString(
dr["ECF_BOLETO"])
?? string.Empty,
ECF_TROCO =
Convert.ToString(
dr["ECF_TROCO"])
?? string.Empty,
DATA_DOCTO =
Convert.ToString(
dr["DATA_DOCTO"])
?? string.Empty,
JUROS =
Convert.ToString(
dr["JUROS"])
?? string.Empty,
DESCONTO =
Convert.ToString(
dr["DESCONTO"])
?? string.Empty,
CFOP =
Convert.ToString(
dr["CFOP"])
?? string.Empty,
CLISTSERV =
Convert.ToString(
dr["CLISTSERV"])
?? string.Empty,
PMVAST =
Convert.ToString(
dr["PMVAST"])
?? string.Empty,
PREDBCST =
Convert.ToString(
dr["PREDBCST"])
?? string.Empty,
VBCICMSST =
Convert.ToString(
dr["VBCICMSST"])
?? string.Empty,
AICMSST =
Convert.ToString(
dr["AICMSST"])
?? string.Empty,
VICMSST =
Convert.ToString(
dr["VICMSST"])
?? string.Empty,
DATA_PGTO =
Convert.ToString(
dr["DATA_PGTO"])
?? string.Empty,
COD_CORRENTE =
Convert.ToString(
dr["COD_CORRENTE"])
?? string.Empty,
OBS_COB =
Convert.ToString(
dr["OBS_COB"])
?? string.Empty
};
}
private static void PreencherParametrosInserir(
SqlCommand cmd,
ModeloContas modelo)
{
cmd.Parameters.AddWithValue("@TIPO", modelo.TIPO);
cmd.Parameters.AddWithValue("@CLIENTE", modelo.CLIENTE);
cmd.Parameters.AddWithValue("@FORNECEDOR", modelo.FORNECEDOR);
cmd.Parameters.AddWithValue("@COD_CLIENTE", modelo.COD_CLIENTE);
cmd.Parameters.AddWithValue("@COD_FORNECEDOR", modelo.COD_FORNECEDOR);
cmd.Parameters.AddWithValue("@VENCIMENTO", modelo.VENCIMENTO);
cmd.Parameters.AddWithValue("@PAGO", modelo.PAGO);
cmd.Parameters.AddWithValue("@PLANO_CONTAS", modelo.PLANO_CONTAS);
cmd.Parameters.AddWithValue("@OBSERVACAO", modelo.OBSERVACAO);
cmd.Parameters.AddWithValue("@VALOR", modelo.VALOR);
cmd.Parameters.AddWithValue("@REFERENCIA", modelo.REFERENCIA);
cmd.Parameters.AddWithValue("@FCOBRANCA", modelo.FCOBRANCA);
cmd.Parameters.AddWithValue("@PARCELA", modelo.PARCELA);
cmd.Parameters.AddWithValue("@ECF_DINHEIRO", modelo.ECF_DINHEIRO);
cmd.Parameters.AddWithValue("@ECF_CHEQUE", modelo.ECF_CHEQUE);
cmd.Parameters.AddWithValue("@ECF_CARTAO", modelo.ECF_CARTAO);
cmd.Parameters.AddWithValue("@ECF_BOLETO", modelo.ECF_BOLETO);
cmd.Parameters.AddWithValue("@ECF_TROCO", modelo.ECF_TROCO);
cmd.Parameters.AddWithValue("@DATA_DOCTO", modelo.DATA_DOCTO);
cmd.Parameters.AddWithValue("@JUROS", modelo.JUROS);
cmd.Parameters.AddWithValue("@DESCONTO", modelo.DESCONTO);
cmd.Parameters.AddWithValue("@CFOP", modelo.CFOP);
cmd.Parameters.AddWithValue("@CLISTSERV", modelo.CLISTSERV);
cmd.Parameters.AddWithValue("@PMVAST", modelo.PMVAST);
cmd.Parameters.AddWithValue("@PREDBCST", modelo.PREDBCST);
cmd.Parameters.AddWithValue("@VBCICMSST", modelo.VBCICMSST);
cmd.Parameters.AddWithValue("@AICMSST", modelo.AICMSST);
cmd.Parameters.AddWithValue("@VICMSST", modelo.VICMSST);
cmd.Parameters.AddWithValue("@DATA_PGTO", modelo.DATA_PGTO);
cmd.Parameters.AddWithValue("@COD_CORRENTE", modelo.COD_CORRENTE);
cmd.Parameters.AddWithValue("@OBS_COB", modelo.OBS_COB);
}
private static void PreencherParametrosAlterar(
SqlCommand cmd,
ModeloContas modelo)
{
cmd.Parameters.AddWithValue(
"@CODIGO",
modelo.CODIGO);
PreencherParametrosInserir(
cmd,
modelo);
}
#endregion
}
}

520
DAL/DALContasContas.cs Normal file
View File

@ -0,0 +1,520 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALContasContas
{
private readonly string connectionString;
public DALContasContas(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloContasContas modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Contas_contas
(
DESCRICAO,
SALDO_INI
)
VALUES
(
@DESCRICAO,
@SALDO_INI
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosInserir(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloContasContas modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contas_contas
SET
CODIGO = @CODIGO,
DESCRICAO = @DESCRICAO,
SALDO_INI = @SALDO_INI
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosAlterar(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
modelo.ID_CONTAS_CONTAS);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Contas_contas
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloContasContas? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_contas
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloContasContas> Listar()
{
List<ModeloContasContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_contas
ORDER BY ID_CONTAS_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContasContas> Listar(string filtro)
{
List<ModeloContasContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_contas
WHERE DESCRICAO LIKE
@FILTRO
ORDER BY ID_CONTAS_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@FILTRO",
$"%{filtro}%");
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContasContas> Listar(int top)
{
List<ModeloContasContas> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = $@"
SELECT TOP {top} *
FROM Contas_contas
ORDER BY ID_CONTAS_CONTAS DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region VIEWS
public List<ModeloContasContas> ListarComSaldo()
{
return ExecutarLista(@"
SELECT *
FROM Contas_contas
WHERE
SALDO_INI IS NOT NULL
AND SALDO_INI <> ''
AND SALDO_INI <> '0'");
}
public List<ModeloContasContas> ListarSemSaldo()
{
return ExecutarLista(@"
SELECT *
FROM Contas_contas
WHERE
SALDO_INI IS NULL
OR SALDO_INI = ''
OR SALDO_INI = '0'");
}
public List<ModeloContasContas> ListarComSaldoInicialMaiorQueZero()
{
return ExecutarLista(@"
SELECT *
FROM Contas_contas
WHERE
ISNUMERIC(SALDO_INI) = 1
AND CAST(SALDO_INI AS DECIMAL(18, 2)) > 0");
}
public List<ModeloContasContas> ListarComSaldoInicialMenorQueZero()
{
return ExecutarLista(@"
SELECT *
FROM Contas_contas
WHERE
ISNUMERIC(SALDO_INI) = 1
AND CAST(SALDO_INI AS DECIMAL(18, 2)) < 0");
}
public List<ModeloContasContas> ListarComSaldoInicialIgualAZero()
{
return ExecutarLista(@"
SELECT *
FROM Contas_contas
WHERE
ISNUMERIC(SALDO_INI) = 1
AND CAST(SALDO_INI AS DECIMAL(18, 2)) = 0");
}
public bool VerificarExistencia(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT COUNT(*) > 0
FROM Contas_contas
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
id);
conn.Open();
return (bool)cmd.ExecuteScalar();
}
public bool FecharContasContas(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contas_contas
SET SALDO_INI = '0'
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool ReabrirContasContas(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contas_contas
SET SALDO_INI = NULL
WHERE ID_CONTAS_CONTAS =
@ID_CONTAS_CONTAS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONTAS_CONTAS",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool ExcluirContasContasFechadas()
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Contas_contas
WHERE SALDO_INI = '0'";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool ExcluirContasContasReabertas()
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Contas_contas
WHERE SALDO_INI IS NULL";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool VerificarContasComSaldo()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT COUNT(*) > 0
FROM Contas_contas
WHERE
SALDO_INI IS NOT NULL
AND SALDO_INI <> ''
AND SALDO_INI <> '0'";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
return (bool)cmd.ExecuteScalar();
}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL_CONTAS
FROM Contas_contas";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private List<ModeloContasContas> ExecutarLista(
string sql)
{
List<ModeloContasContas> 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 ModeloContasContas PreencherModelo(
SqlDataReader dr)
{
return new ModeloContasContas
{
ID_CONTAS_CONTAS =
Convert.ToInt32(
dr["ID_CONTAS_CONTAS"]),
CODIGO =
Convert.ToString(
dr["CODIGO"])
?? string.Empty,
DESCRICAO =
Convert.ToString(
dr["DESCRICAO"])
?? string.Empty,
SALDO_INI =
Convert.ToString(
dr["SALDO_INI"])
?? string.Empty
};
}
private static void PreencherParametrosInserir(
SqlCommand cmd,
ModeloContasContas modelo)
{
cmd.Parameters.AddWithValue(
"@DESCRICAO",
string.IsNullOrWhiteSpace(
modelo.DESCRICAO)
? DBNull.Value
: modelo.DESCRICAO);
cmd.Parameters.AddWithValue(
"@SALDO_INI",
string.IsNullOrWhiteSpace(
modelo.SALDO_INI)
? DBNull.Value
: modelo.SALDO_INI);
}
private static void PreencherParametrosAlterar(
SqlCommand cmd,
ModeloContasContas modelo)
{
cmd.Parameters.AddWithValue(
"@CODIGO",
string.IsNullOrWhiteSpace(
modelo.CODIGO)
? DBNull.Value
: modelo.CODIGO);
PreencherParametrosInserir(
cmd,
modelo);
}
#endregion
}
}

380
DAL/DALContasDeposito.cs Normal file
View File

@ -0,0 +1,380 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALContasDeposito
{
private readonly string connectionString;
public DALContasDeposito(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloContasDeposito modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Contas_depositos
(
COD_CORRENTE,
COD_LANCTO,
VALOR,
DATA_CADASTRO
)
VALUES
(
@COD_CORRENTE,
@COD_LANCTO,
@VALOR,
@DATA_CADASTRO
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosInserir(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloContasDeposito modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contas_depositos
SET
CODIGO = @CODIGO,
COD_CORRENTE = @COD_CORRENTE,
COD_LANCTO = @COD_LANCTO,
VALOR = @VALOR,
DATA_CADASTRO = @DATA_CADASTRO
WHERE ID_COD_CONTA_DEPO =
@ID_COD_CONTA_DEPO";
using SqlCommand cmd =
new(sql, conn);
PreencherParametrosAlterar(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@ID_COD_CONTA_DEPO",
modelo.ID_COD_CONTA_DEPO);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Contas_depositos
WHERE ID_COD_CONTA_DEPO =
@ID_COD_CONTA_DEPO";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_COD_CONTA_DEPO",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloContasDeposito? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_depositos
WHERE ID_COD_CONTA_DEPO =
@ID_COD_CONTA_DEPO";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_COD_CONTA_DEPO",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloContasDeposito> Listar()
{
List<ModeloContasDeposito> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_depositos
ORDER BY ID_COD_CONTA_DEPO DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region VIEWS
public List<ModeloContasDeposito> ListarPorConta(
string codCorrente)
{
List<ModeloContasDeposito> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_depositos
WHERE COD_CORRENTE =
@COD_CORRENTE";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@COD_CORRENTE",
codCorrente);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContasDeposito> ListarPorLancamento(
string codLancto)
{
List<ModeloContasDeposito> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contas_depositos
WHERE COD_LANCTO =
@COD_LANCTO";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@COD_LANCTO",
codLancto);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL_DEPOSITOS
FROM Contas_depositos";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private static ModeloContasDeposito PreencherModelo(
SqlDataReader dr)
{
return new ModeloContasDeposito
{
ID_COD_CONTA_DEPO =
Convert.ToInt32(
dr["ID_COD_CONTA_DEPO"]),
CODIGO =
Convert.ToString(
dr["CODIGO"])
?? string.Empty,
COD_CORRENTE =
Convert.ToString(
dr["COD_CORRENTE"])
?? string.Empty,
COD_LANCTO =
Convert.ToString(
dr["COD_LANCTO"])
?? string.Empty,
VALOR =
Convert.ToString(
dr["VALOR"])
?? string.Empty,
DATA_CADASTRO =
Convert.ToString(
dr["DATA_CADASTRO"])
?? string.Empty
};
}
private static void PreencherParametrosInserir(
SqlCommand cmd,
ModeloContasDeposito modelo)
{
cmd.Parameters.AddWithValue(
"@COD_CORRENTE",
string.IsNullOrWhiteSpace(
modelo.COD_CORRENTE)
? DBNull.Value
: modelo.COD_CORRENTE);
cmd.Parameters.AddWithValue(
"@COD_LANCTO",
string.IsNullOrWhiteSpace(
modelo.COD_LANCTO)
? DBNull.Value
: modelo.COD_LANCTO);
cmd.Parameters.AddWithValue(
"@VALOR",
string.IsNullOrWhiteSpace(
modelo.VALOR)
? DBNull.Value
: modelo.VALOR);
cmd.Parameters.AddWithValue(
"@DATA_CADASTRO",
string.IsNullOrWhiteSpace(
modelo.DATA_CADASTRO)
? DBNull.Value
: modelo.DATA_CADASTRO);
}
private static void PreencherParametrosAlterar(
SqlCommand cmd,
ModeloContasDeposito modelo)
{
cmd.Parameters.AddWithValue(
"@CODIGO",
string.IsNullOrWhiteSpace(
modelo.CODIGO)
? DBNull.Value
: modelo.CODIGO);
PreencherParametrosInserir(
cmd,
modelo);
}
#endregion
}
}

393
DAL/DALLClientesEnderecos.cs Normal file
View File

@ -0,0 +1,393 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALLClientesEnderecos
{
private readonly string connectionString;
public DALLClientesEnderecos(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloClientesEnderecos modelo)
{
try
{
using SqlConnection conn = new(connectionString);
string query = @"
INSERT INTO Clientes_enderecos
(
COD_CLIENTE,
LOGRADOURO,
NUMERO,
COMPLEM,
BAIRRO,
CIDADE,
UF,
CEP,
DATA_CADASTRO
)
VALUES
(
@COD_CLIENTE,
@LOGRADOURO,
@NUMERO,
@COMPLEM,
@BAIRRO,
@CIDADE,
@UF,
@CEP,
@DATA_CADASTRO
)";
using SqlCommand cmd = new(query, conn);
PreencherParametrosInserir(cmd, modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}//Inserir
public bool Alterar(ModeloClientesEnderecos modelo)
{
try
{
using SqlConnection conn = new(connectionString);
string query = @"
UPDATE Clientes_enderecos
SET
CODIGO = @CODIGO,
COD_CLIENTE = @COD_CLIENTE,
LOGRADOURO = @LOGRADOURO,
NUMERO = @NUMERO,
COMPLEM = @COMPLEM,
BAIRRO = @BAIRRO,
CIDADE = @CIDADE,
UF = @UF,
CEP = @CEP,
DATA_CADASTRO = @DATA_CADASTRO
WHERE ID_COD_CLIENTE_END = @ID_COD_CLIENTE_END";
using SqlCommand cmd = new(query, conn);
PreencherParametrosAlterar(cmd, modelo);
cmd.Parameters.AddWithValue(
"@ID_COD_CLIENTE_END",
modelo.ID_COD_CLIENTE_END);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}//alterar
public bool Excluir(int id)
{
try
{
using SqlConnection conn = new(connectionString);
string query = @"
DELETE FROM Clientes_enderecos
WHERE ID_COD_CLIENTE_END =
@ID_COD_CLIENTE_END";
using SqlCommand cmd = new(query, conn);
cmd.Parameters.AddWithValue(
"@ID_COD_CLIENTE_END",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}//Excluir
public ModeloClientesEnderecos? Carregar(int id)
{
using SqlConnection conn = new(connectionString);
string query = @"
SELECT *
FROM Clientes_enderecos
WHERE ID_COD_CLIENTE_END =
@ID_COD_CLIENTE_END";
using SqlCommand cmd = new(query, conn);
cmd.Parameters.AddWithValue(
"@ID_COD_CLIENTE_END",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}//CarregarOuObter
public List<ModeloClientesEnderecos> Listar()
{
List<ModeloClientesEnderecos> lista = [];
using SqlConnection conn = new(connectionString);
string query = @"
SELECT *
FROM Clientes_enderecos
ORDER BY ID_COD_CLIENTE_END DESC";
using SqlCommand cmd = new(query, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(PreencherModelo(dr));
}
return lista;
}//listar clientes
public List<ModeloClientesEnderecos> ListarPorCliente(string codCliente)
{
List<ModeloClientesEnderecos> lista = [];
using SqlConnection conn = new(connectionString);
string query = @"
SELECT *
FROM Clientes_enderecos
WHERE COD_CLIENTE =
@COD_CLIENTE
ORDER BY ID_COD_CLIENTE_END DESC";
using SqlCommand cmd = new(query, conn);
cmd.Parameters.AddWithValue(
"@COD_CLIENTE",
codCliente);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(PreencherModelo(dr));
}
return lista;
}//listar clientes por cliente
public int ObterTotalPorCliente(string codCliente)
{
using SqlConnection conn = new(connectionString);
string query = @"
SELECT COUNT(*)
FROM Clientes_enderecos
WHERE COD_CLIENTE =
@COD_CLIENTE";
using SqlCommand cmd = new(query, conn);
cmd.Parameters.AddWithValue(
"@COD_CLIENTE",
codCliente);
conn.Open();
return Convert.ToInt32(cmd.ExecuteScalar());
}//obter total por cliente
public int ObterTotal()
{
using SqlConnection conn = new(connectionString);
string query = @"
SELECT COUNT(*)
FROM Clientes_enderecos";
using SqlCommand cmd = new(query, conn);
conn.Open();
return Convert.ToInt32(cmd.ExecuteScalar());
}//obter total
public bool Existe(int id)
{
using SqlConnection conn = new(connectionString);
string query = @"
SELECT COUNT(*)
FROM Clientes_enderecos
WHERE ID_COD_CLIENTE_END =
@ID_COD_CLIENTE_END";
using SqlCommand cmd = new(query, conn);
cmd.Parameters.AddWithValue(
"@ID_COD_CLIENTE_END",
id);
conn.Open();
return Convert.ToInt32(cmd.ExecuteScalar()) > 0;
}//existe
#endregion
#region HELPERS
private static ModeloClientesEnderecos PreencherModelo(
SqlDataReader dr)
{
return new ModeloClientesEnderecos
{
ID_COD_CLIENTE_END =
Convert.ToInt32(
dr["ID_COD_CLIENTE_END"]),
CODIGO =
Convert.ToString(
dr["CODIGO"]) ?? string.Empty,
COD_CLIENTE =
Convert.ToString(
dr["COD_CLIENTE"]) ?? string.Empty,
LOGRADOURO =
Convert.ToString(
dr["LOGRADOURO"]) ?? string.Empty,
NUMERO =
Convert.ToString(
dr["NUMERO"]) ?? string.Empty,
COMPLEM =
Convert.ToString(
dr["COMPLEM"]) ?? string.Empty,
BAIRRO =
Convert.ToString(
dr["BAIRRO"]) ?? string.Empty,
CIDADE =
Convert.ToString(
dr["CIDADE"]) ?? string.Empty,
UF =
Convert.ToString(
dr["UF"]) ?? string.Empty,
CEP =
Convert.ToString(
dr["CEP"]) ?? string.Empty,
DATA_CADASTRO =
Convert.ToString(
dr["DATA_CADASTRO"]) ?? string.Empty
};
}
private static void PreencherParametrosInserir(
SqlCommand cmd,
ModeloClientesEnderecos modelo)
{
cmd.Parameters.AddWithValue(
"@COD_CLIENTE",
string.IsNullOrWhiteSpace(
modelo.COD_CLIENTE)
? DBNull.Value
: modelo.COD_CLIENTE);
cmd.Parameters.AddWithValue(
"@LOGRADOURO",
string.IsNullOrWhiteSpace(
modelo.LOGRADOURO)
? DBNull.Value
: modelo.LOGRADOURO);
cmd.Parameters.AddWithValue(
"@NUMERO",
string.IsNullOrWhiteSpace(
modelo.NUMERO)
? DBNull.Value
: modelo.NUMERO);
cmd.Parameters.AddWithValue(
"@COMPLEM",
string.IsNullOrWhiteSpace(
modelo.COMPLEM)
? DBNull.Value
: modelo.COMPLEM);
cmd.Parameters.AddWithValue(
"@BAIRRO",
string.IsNullOrWhiteSpace(
modelo.BAIRRO)
? DBNull.Value
: modelo.BAIRRO);
cmd.Parameters.AddWithValue(
"@CIDADE",
string.IsNullOrWhiteSpace(
modelo.CIDADE)
? DBNull.Value
: modelo.CIDADE);
cmd.Parameters.AddWithValue(
"@UF",
string.IsNullOrWhiteSpace(
modelo.UF)
? DBNull.Value
: modelo.UF);
cmd.Parameters.AddWithValue(
"@CEP",
string.IsNullOrWhiteSpace(
modelo.CEP)
? DBNull.Value
: modelo.CEP);
cmd.Parameters.AddWithValue(
"@DATA_CADASTRO",
string.IsNullOrWhiteSpace(
modelo.DATA_CADASTRO)
? DBNull.Value
: modelo.DATA_CADASTRO);
}
private static void PreencherParametrosAlterar(
SqlCommand cmd,
ModeloClientesEnderecos modelo)
{
cmd.Parameters.AddWithValue(
"@CODIGO",
string.IsNullOrWhiteSpace(
modelo.CODIGO)
? DBNull.Value
: modelo.CODIGO);
PreencherParametrosInserir(
cmd,
modelo);
}
#endregion
}
}

252
DAL/DALLConfig.cs Normal file
View File

@ -0,0 +1,252 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace DALL
{
public class DALLConfig
{
private readonly string connectionString;
public DALLConfig(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloConfig modelo)
{
try
{
using SqlConnection conn = new(connectionString);
PropertyInfo[] props =
typeof(ModeloConfig)
.GetProperties()
.Where(p => p.Name != "ID_CONFIG")
.ToArray();
string colunas =
string.Join(",",
props.Select(p => p.Name));
string parametros =
string.Join(",",
props.Select(p => "@" + p.Name));
string sql = $@"
INSERT INTO Config
(
{colunas}
)
VALUES
(
{parametros}
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(cmd, modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloConfig modelo)
{
try
{
using SqlConnection conn = new(connectionString);
PropertyInfo[] props =
typeof(ModeloConfig)
.GetProperties()
.Where(p => p.Name != "ID_CONFIG")
.ToArray();
string sets =
string.Join(",",
props.Select(p =>
$"{p.Name}=@{p.Name}"));
string sql = $@"
UPDATE Config
SET
{sets}
WHERE ID_CONFIG=@ID_CONFIG";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(cmd, modelo);
cmd.Parameters.AddWithValue(
"@ID_CONFIG",
modelo.ID_CONFIG);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql =
"DELETE FROM Config WHERE ID_CONFIG=@ID_CONFIG";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONFIG",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloConfig? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Config
WHERE ID_CONFIG=@ID_CONFIG";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONFIG",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloConfig> Listar()
{
List<ModeloConfig> lista = [];
using SqlConnection conn =
new(connectionString);
string sql =
"SELECT * FROM Config ORDER BY ID_CONFIG";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region HELPERS
private static ModeloConfig PreencherModelo(
SqlDataReader dr)
{
ModeloConfig modelo = new();
PropertyInfo[] props =
typeof(ModeloConfig)
.GetProperties();
foreach (PropertyInfo prop in props)
{
try
{
if (dr[prop.Name] != DBNull.Value)
{
prop.SetValue(
modelo,
Convert.ToString(
dr[prop.Name]));
}
}
catch
{
}
}
modelo.ID_CONFIG =
Convert.ToInt32(
dr["ID_CONFIG"]);
return modelo;
}
private static void PreencherParametros(
SqlCommand cmd,
ModeloConfig modelo)
{
PropertyInfo[] props =
typeof(ModeloConfig)
.GetProperties()
.Where(p => p.Name != "ID_CONFIG")
.ToArray();
foreach (PropertyInfo prop in props)
{
object? valor =
prop.GetValue(modelo);
cmd.Parameters.AddWithValue(
"@" + prop.Name,
valor ?? DBNull.Value);
}
}
#endregion
}
}

492
DAL/DALLContasPagar.cs Normal file
View File

@ -0,0 +1,492 @@
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
}
}

537
DAL/DALLContasReceber.cs Normal file
View File

@ -0,0 +1,537 @@
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
}
}

954
DAL/DALLContratoEquipamentos.cs Normal file
View File

@ -0,0 +1,954 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALLContratoEquipamentos
{
private readonly string connectionString;
public DALLContratoEquipamentos(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(
ModeloContratoEquipamentos modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO ContratoEquipamentos
(
ContratoId,
Modelo,
Marca,
Operadora,
Serial,
NumeroPatrimonio,
Observacoes
)
VALUES
(
@ContratoId,
@Modelo,
@Marca,
@Operadora,
@Serial,
@NumeroPatrimonio,
@Observacoes
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(
ModeloContratoEquipamentos modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE ContratoEquipamentos
SET
ContratoId = @ContratoId,
Modelo = @Modelo,
Marca = @Marca,
Operadora = @Operadora,
Serial = @Serial,
NumeroPatrimonio = @NumeroPatrimonio,
Observacoes = @Observacoes
WHERE Id_equipamentos =
@Id_equipamentos";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@Id_equipamentos",
modelo.Id_equipamentos);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM ContratoEquipamentos
WHERE Id_equipamentos =
@Id_equipamentos";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Id_equipamentos",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloContratoEquipamentos? Carregar(
int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Id_equipamentos =
@Id_equipamentos";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Id_equipamentos",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloContratoEquipamentos> Listar()
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoId(int contratoId)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorMarca(string marca)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Marca =
@Marca
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Marca",
marca);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorSerial(string serial)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Serial =
@Serial
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Serial",
serial);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorNumeroPatrimonio(string numeroPatrimonio)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE NumeroPatrimonio =
@NumeroPatrimonio
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@NumeroPatrimonio",
numeroPatrimonio);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorObservacoes(string observacoes)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Observacoes LIKE
'%' + @Observacoes + '%'
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Observacoes",
observacoes);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorModelo(string modelo)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Modelo =
@Modelo
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Modelo",
modelo);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorOperadora(string operadora)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE Operadora =
@Operadora
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Operadora",
operadora);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdMarca(int contratoId, string marca)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND Marca =
@Marca
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@Marca",
marca);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdSerial(int contratoId, string serial)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND Serial =
@Serial
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@Serial",
serial);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdNumeroPatrimonio(int contratoId, string numeroPatrimonio)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND NumeroPatrimonio =
@NumeroPatrimonio
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@NumeroPatrimonio",
numeroPatrimonio);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdObservacoes(int contratoId, string observacoes)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND Observacoes LIKE
'%' + @Observacoes + '%'
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@Observacoes",
observacoes);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdModelo(int contratoId, string modelo)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND Modelo =
@Modelo
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@Modelo",
modelo);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarPorContratoIdOperadora(int contratoId, string operadora)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId AND Operadora =
@Operadora
ORDER BY Id_equipamentos DESC";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
cmd.Parameters.AddWithValue(
"@Operadora",
operadora);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContratoEquipamentos> ListarOtimizado( int? contratoId = null,string? modelo = null, string? marca = null, string? operadora = null, string? serial = null, string? numeroPatrimonio = null, string? observacoes = null)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE 1 = 1";
using SqlCommand cmd =
new();
cmd.Connection = conn;
// ─────────────────────────────────────
// CONTRATO
// ─────────────────────────────────────
if (contratoId.HasValue)
{
sql += @"
AND ContratoId =
@ContratoId";
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId.Value);
}
// ─────────────────────────────────────
// MODELO
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(modelo))
{
sql += @"
AND Modelo LIKE
@Modelo";
cmd.Parameters.AddWithValue(
"@Modelo",
"%" + modelo + "%");
}
// ─────────────────────────────────────
// MARCA
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(marca))
{
sql += @"
AND Marca LIKE
@Marca";
cmd.Parameters.AddWithValue(
"@Marca",
"%" + marca + "%");
}
// ─────────────────────────────────────
// OPERADORA
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(operadora))
{
sql += @"
AND Operadora LIKE
@Operadora";
cmd.Parameters.AddWithValue(
"@Operadora",
"%" + operadora + "%");
}
// ─────────────────────────────────────
// SERIAL
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(serial))
{
sql += @"
AND Serial LIKE
@Serial";
cmd.Parameters.AddWithValue(
"@Serial",
"%" + serial + "%");
}
// ─────────────────────────────────────
// PATRIMONIO
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(numeroPatrimonio))
{
sql += @"
AND NumeroPatrimonio LIKE
@NumeroPatrimonio";
cmd.Parameters.AddWithValue(
"@NumeroPatrimonio",
"%" + numeroPatrimonio + "%");
}
// ─────────────────────────────────────
// OBSERVAÇÕES
// ─────────────────────────────────────
if (!string.IsNullOrWhiteSpace(observacoes))
{
sql += @"
AND Observacoes LIKE
@Observacoes";
cmd.Parameters.AddWithValue(
"@Observacoes",
"%" + observacoes + "%");
}
// ─────────────────────────────────────
sql += @"
ORDER BY
Id_equipamentos DESC";
cmd.CommandText = sql;
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region VIEWS
public List<ModeloContratoEquipamentos>
ListarPorContrato(
int contratoId)
{
List<ModeloContratoEquipamentos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM ContratoEquipamentos
WHERE ContratoId =
@ContratoId";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ContratoId",
contratoId);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
//public List<ModeloContratoEquipamentos>
// ListarPorMarca(
// string marca)
//{
// List<ModeloContratoEquipamentos> lista = [];
// using SqlConnection conn =
// new(connectionString);
// string sql = @"
// SELECT *
// FROM ContratoEquipamentos
// WHERE Marca =
// @Marca";
// using SqlCommand cmd =
// new(sql, conn);
// cmd.Parameters.AddWithValue(
// "@Marca",
// marca);
// conn.Open();
// using SqlDataReader dr =
// cmd.ExecuteReader();
// while (dr.Read())
// {
// lista.Add(
// PreencherModelo(dr));
// }
// return lista;
//}
//public List<ModeloContratoEquipamentos>
// ListarPorSerial(
// string serial)
//{
// List<ModeloContratoEquipamentos> lista = [];
// using SqlConnection conn =
// new(connectionString);
// string sql = @"
// SELECT *
// FROM ContratoEquipamentos
// WHERE Serial =
// @Serial";
// using SqlCommand cmd =
// new(sql, conn);
// cmd.Parameters.AddWithValue(
// "@Serial",
// serial);
// conn.Open();
// using SqlDataReader dr =
// cmd.ExecuteReader();
// while (dr.Read())
// {
// lista.Add(
// PreencherModelo(dr));
// }
// return lista;
//}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL_EQUIPAMENTOS
FROM ContratoEquipamentos";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private static ModeloContratoEquipamentos
PreencherModelo(
SqlDataReader dr)
{
return new ModeloContratoEquipamentos
{
Id_equipamentos =
Convert.ToInt32(
dr["Id_equipamentos"]),
ContratoId =
Convert.ToInt32(
dr["ContratoId"]),
Modelo =
dr["Modelo"] == DBNull.Value
? null
: Convert.ToString(
dr["Modelo"]),
Marca =
dr["Marca"] == DBNull.Value
? null
: Convert.ToString(
dr["Marca"]),
Operadora =
dr["Operadora"] == DBNull.Value
? null
: Convert.ToString(
dr["Operadora"]),
Serial =
dr["Serial"] == DBNull.Value
? null
: Convert.ToString(
dr["Serial"]),
NumeroPatrimonio =
dr["NumeroPatrimonio"]
== DBNull.Value
? null
: Convert.ToString(
dr["NumeroPatrimonio"]),
Observacoes =
dr["Observacoes"]
== DBNull.Value
? null
: Convert.ToString(
dr["Observacoes"])
};
}
private static void PreencherParametros(
SqlCommand cmd,
ModeloContratoEquipamentos modelo)
{
cmd.Parameters.AddWithValue(
"@ContratoId",
modelo.ContratoId);
cmd.Parameters.AddWithValue(
"@Modelo",
string.IsNullOrWhiteSpace(
modelo.Modelo)
? DBNull.Value
: modelo.Modelo);
cmd.Parameters.AddWithValue(
"@Marca",
string.IsNullOrWhiteSpace(
modelo.Marca)
? DBNull.Value
: modelo.Marca);
cmd.Parameters.AddWithValue(
"@Operadora",
string.IsNullOrWhiteSpace(
modelo.Operadora)
? DBNull.Value
: modelo.Operadora);
cmd.Parameters.AddWithValue(
"@Serial",
string.IsNullOrWhiteSpace(
modelo.Serial)
? DBNull.Value
: modelo.Serial);
cmd.Parameters.AddWithValue(
"@NumeroPatrimonio",
string.IsNullOrWhiteSpace(
modelo.NumeroPatrimonio)
? DBNull.Value
: modelo.NumeroPatrimonio);
cmd.Parameters.AddWithValue(
"@Observacoes",
string.IsNullOrWhiteSpace(
modelo.Observacoes)
? DBNull.Value
: modelo.Observacoes);
}
#endregion
}
}

595
DAL/DALLContratos.cs Normal file
View File

@ -0,0 +1,595 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALLContratos
{
private readonly string connectionString;
public DALLContratos(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloContrato modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Contratos
(
EmpresaId,
ClienteId,
Descricao,
Observacoes,
Valor,
DataInicio,
DataValidade,
FranquiaTempo,
Ativo,
CriadoEm,
AtualizadoEm
)
VALUES
(
@EmpresaId,
@ClienteId,
@Descricao,
@Observacoes,
@Valor,
@DataInicio,
@DataValidade,
@FranquiaTempo,
@Ativo,
@CriadoEm,
@AtualizadoEm
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloContrato modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Contratos
SET
EmpresaId = @EmpresaId,
ClienteId = @ClienteId,
Descricao = @Descricao,
Observacoes = @Observacoes,
Valor = @Valor,
DataInicio = @DataInicio,
DataValidade = @DataValidade,
FranquiaTempo = @FranquiaTempo,
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;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Contratos
WHERE Id = @Id";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Id",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloContrato? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
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;
}
public List<ModeloContrato> Listar()
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
ORDER BY Id DESC";
using SqlCommand cmd =
new(sql, conn);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region VIEWS
public List<ModeloContrato> ListarAtivos()
{
return ExecutarLista(@"
SELECT *
FROM Contratos
WHERE Ativo = 1");
}
public List<ModeloContrato> ListarInativos()
{
return ExecutarLista(@"
SELECT *
FROM Contratos
WHERE Ativo = 0");
}
public List<ModeloContrato> ListarVencidos()
{
return ExecutarLista(@"
SELECT *
FROM Contratos
WHERE
DataValidade < GETDATE()
AND Ativo = 1");
}
public List<ModeloContrato> ListarVigentes()
{
return ExecutarLista(@"
SELECT *
FROM Contratos
WHERE
DataValidade >= GETDATE()
AND Ativo = 1");
}
public List<ModeloContrato> ListarPorCliente(
int clienteId)
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
WHERE ClienteId = @ClienteId";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ClienteId",
clienteId);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContrato> ListarPorEmpresa(
int empresaId)
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
WHERE EmpresaId = @EmpresaId";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@EmpresaId",
empresaId);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContrato> ListarPorValor(
decimal valorMinimo,
decimal valorMaximo)
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
WHERE Valor BETWEEN @ValorMinimo AND @ValorMaximo";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ValorMinimo",
valorMinimo);
cmd.Parameters.AddWithValue(
"@ValorMaximo",
valorMaximo);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContrato> ListarPorDataValidade(
DateTime dataInicio,
DateTime dataFim)
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
WHERE DataValidade BETWEEN @DataInicio AND @DataFim";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@DataInicio",
dataInicio);
cmd.Parameters.AddWithValue(
"@DataFim",
dataFim);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
public List<ModeloContrato> ListarContratosEncerrados(
int dias)
{
List<ModeloContrato> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Contratos
WHERE
DataValidade < GETDATE()
AND DATEDIFF(DAY, DataValidade, GETDATE()) <= @Dias";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@Dias",
dias);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL,
SUM(
CASE
WHEN Ativo = 1
THEN 1
ELSE 0
END
) AS ATIVOS,
SUM(
CASE
WHEN Ativo = 0
THEN 1
ELSE 0
END
) AS INATIVOS,
SUM(Valor) AS VALOR_TOTAL
FROM Contratos";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private List<ModeloContrato> ExecutarLista(
string sql)
{
List<ModeloContrato> 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 ModeloContrato PreencherModelo(
SqlDataReader dr)
{
return new ModeloContrato
{
Id =
Convert.ToInt32(
dr["Id"]),
EmpresaId =
Convert.ToInt32(
dr["EmpresaId"]),
ClienteId =
Convert.ToInt32(
dr["ClienteId"]),
Descricao =
dr["Descricao"] == DBNull.Value
? null
: Convert.ToString(
dr["Descricao"]),
Observacoes =
dr["Observacoes"] == DBNull.Value
? null
: Convert.ToString(
dr["Observacoes"]),
Valor =
Convert.ToDecimal(
dr["Valor"]),
DataInicio =
dr["DataInicio"] == DBNull.Value
? (DateTime?)null
: Convert.ToDateTime(
dr["DataInicio"]),
DataValidade =
dr["DataValidade"] == DBNull.Value
? (DateTime?)null
: Convert.ToDateTime(
dr["DataValidade"]),
FranquiaTempo =
dr["FranquiaTempo"] == DBNull.Value
? (int?)null
: Convert.ToInt32(
dr["FranquiaTempo"]),
Ativo =
Convert.ToBoolean(
dr["Ativo"]),
CriadoEm =
dr["CriadoEm"] == DBNull.Value
? (DateTime?)null
: Convert.ToDateTime(
dr["CriadoEm"]),
AtualizadoEm =
dr["AtualizadoEm"] == DBNull.Value
? (DateTime?)null
: Convert.ToDateTime(
dr["AtualizadoEm"])
};
}
private static void PreencherParametros(
SqlCommand cmd,
ModeloContrato modelo)
{
cmd.Parameters.AddWithValue(
"@EmpresaId",
modelo.EmpresaId);
cmd.Parameters.AddWithValue(
"@ClienteId",
modelo.ClienteId);
cmd.Parameters.AddWithValue(
"@Descricao",
string.IsNullOrWhiteSpace(
modelo.Descricao)
? DBNull.Value
: modelo.Descricao);
cmd.Parameters.AddWithValue(
"@Observacoes",
string.IsNullOrWhiteSpace(
modelo.Observacoes)
? DBNull.Value
: modelo.Observacoes);
cmd.Parameters.AddWithValue(
"@Valor",
modelo.Valor);
cmd.Parameters.AddWithValue(
"@DataInicio",
modelo.DataInicio.HasValue
? modelo.DataInicio.Value
: DBNull.Value);
cmd.Parameters.AddWithValue(
"@DataValidade",
modelo.DataValidade.HasValue
? modelo.DataValidade.Value
: DBNull.Value);
cmd.Parameters.AddWithValue(
"@FranquiaTempo",
modelo.FranquiaTempo.HasValue
? modelo.FranquiaTempo.Value
: DBNull.Value);
cmd.Parameters.AddWithValue(
"@Ativo",
modelo.Ativo);
cmd.Parameters.AddWithValue(
"@CriadoEm",
modelo.CriadoEm.HasValue
? modelo.CriadoEm.Value
: DBNull.Value);
cmd.Parameters.AddWithValue(
"@AtualizadoEm",
modelo.AtualizadoEm.HasValue
? modelo.AtualizadoEm.Value
: DBNull.Value);
}
#endregion
}
}

633
DAL/DALLConvenioBoletos.cs Normal file
View File

@ -0,0 +1,633 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALLConvenioBoletos
{
private readonly string connectionString;
public DALLConvenioBoletos(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloConvenioBoletos modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Convenio_boletos
(
BANCO,
CARTEIRA,
CONVENIO,
AGENCIA,
CONTA,
NOME_CEDENTE,
LOCAL_PGTO,
INSTRU_01,
INSTRU_02,
INSTRU_03,
INSTRU_04,
INSTRU_05,
INSTRU_06,
INSTRU_07,
INSTRU_08,
INSTRU_09,
INSTRU_10,
DIAS_PROTESTO,
TIPO_DOC_COB,
TIPO_ESP_DOC
)
VALUES
(
@BANCO,
@CARTEIRA,
@CONVENIO,
@AGENCIA,
@CONTA,
@NOME_CEDENTE,
@LOCAL_PGTO,
@INSTRU_01,
@INSTRU_02,
@INSTRU_03,
@INSTRU_04,
@INSTRU_05,
@INSTRU_06,
@INSTRU_07,
@INSTRU_08,
@INSTRU_09,
@INSTRU_10,
@DIAS_PROTESTO,
@TIPO_DOC_COB,
@TIPO_ESP_DOC
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloConvenioBoletos modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Convenio_boletos
SET
CODIGO = @CODIGO,
BANCO = @BANCO,
CARTEIRA = @CARTEIRA,
CONVENIO = @CONVENIO,
AGENCIA = @AGENCIA,
CONTA = @CONTA,
NOME_CEDENTE = @NOME_CEDENTE,
LOCAL_PGTO = @LOCAL_PGTO,
INSTRU_01 = @INSTRU_01,
INSTRU_02 = @INSTRU_02,
INSTRU_03 = @INSTRU_03,
INSTRU_04 = @INSTRU_04,
INSTRU_05 = @INSTRU_05,
INSTRU_06 = @INSTRU_06,
INSTRU_07 = @INSTRU_07,
INSTRU_08 = @INSTRU_08,
INSTRU_09 = @INSTRU_09,
INSTRU_10 = @INSTRU_10,
DIAS_PROTESTO = @DIAS_PROTESTO,
TIPO_DOC_COB = @TIPO_DOC_COB,
TIPO_ESP_DOC = @TIPO_ESP_DOC
WHERE ID_CONVENIO_BOLETOS =
@ID_CONVENIO_BOLETOS";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@CODIGO",
modelo.CODIGO);
cmd.Parameters.AddWithValue(
"@ID_CONVENIO_BOLETOS",
modelo.ID_CONVENIO_BOLETOS);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Convenio_boletos
WHERE ID_CONVENIO_BOLETOS =
@ID_CONVENIO_BOLETOS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONVENIO_BOLETOS",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloConvenioBoletos? Carregar( int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Convenio_boletos
WHERE ID_CONVENIO_BOLETOS =
@ID_CONVENIO_BOLETOS";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONVENIO_BOLETOS",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloConvenioBoletos> ListarOtimizado(
string? banco = null,
string? carteira = null,
string? convenio = null,
string? agencia = null,
string? conta = null,
string? nomeCedente = null,
string? tipoDoc = null)
{
List<ModeloConvenioBoletos> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Convenio_boletos
WHERE 1 = 1";
using SqlCommand cmd =
new();
cmd.Connection = conn;
if (!string.IsNullOrWhiteSpace(
banco))
{
sql += @"
AND BANCO LIKE @BANCO";
cmd.Parameters.AddWithValue(
"@BANCO",
"%" + banco + "%");
}
if (!string.IsNullOrWhiteSpace(
carteira))
{
sql += @"
AND CARTEIRA LIKE
@CARTEIRA";
cmd.Parameters.AddWithValue(
"@CARTEIRA",
"%" + carteira + "%");
}
if (!string.IsNullOrWhiteSpace(
convenio))
{
sql += @"
AND CONVENIO LIKE
@CONVENIO";
cmd.Parameters.AddWithValue(
"@CONVENIO",
"%" + convenio + "%");
}
if (!string.IsNullOrWhiteSpace(
agencia))
{
sql += @"
AND AGENCIA LIKE
@AGENCIA";
cmd.Parameters.AddWithValue(
"@AGENCIA",
"%" + agencia + "%");
}
if (!string.IsNullOrWhiteSpace(
conta))
{
sql += @"
AND CONTA LIKE
@CONTA";
cmd.Parameters.AddWithValue(
"@CONTA",
"%" + conta + "%");
}
if (!string.IsNullOrWhiteSpace(
nomeCedente))
{
sql += @"
AND NOME_CEDENTE LIKE
@NOME_CEDENTE";
cmd.Parameters.AddWithValue(
"@NOME_CEDENTE",
"%" + nomeCedente + "%");
}
if (!string.IsNullOrWhiteSpace(
tipoDoc))
{
sql += @"
AND TIPO_DOC_COB LIKE
@TIPO_DOC_COB";
cmd.Parameters.AddWithValue(
"@TIPO_DOC_COB",
"%" + tipoDoc + "%");
}
sql += @"
ORDER BY
ID_CONVENIO_BOLETOS DESC";
cmd.CommandText = sql;
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL_CONVENIOS
FROM Convenio_boletos";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private static ModeloConvenioBoletos
PreencherModelo(
SqlDataReader dr)
{
return new ModeloConvenioBoletos
{
ID_CONVENIO_BOLETOS =
Convert.ToInt32(
dr["ID_CONVENIO_BOLETOS"]),
CODIGO =
Convert.ToString(
dr["CODIGO"])
?? string.Empty,
BANCO =
Convert.ToString(
dr["BANCO"])
?? string.Empty,
CARTEIRA =
Convert.ToString(
dr["CARTEIRA"])
?? string.Empty,
CONVENIO =
Convert.ToString(
dr["CONVENIO"])
?? string.Empty,
AGENCIA =
Convert.ToString(
dr["AGENCIA"])
?? string.Empty,
CONTA =
Convert.ToString(
dr["CONTA"])
?? string.Empty,
NOME_CEDENTE =
Convert.ToString(
dr["NOME_CEDENTE"])
?? string.Empty,
LOCAL_PGTO =
Convert.ToString(
dr["LOCAL_PGTO"])
?? string.Empty,
INSTRU_01 =
Convert.ToString(
dr["INSTRU_01"])
?? string.Empty,
INSTRU_02 =
Convert.ToString(
dr["INSTRU_02"])
?? string.Empty,
INSTRU_03 =
Convert.ToString(
dr["INSTRU_03"])
?? string.Empty,
INSTRU_04 =
Convert.ToString(
dr["INSTRU_04"])
?? string.Empty,
INSTRU_05 =
Convert.ToString(
dr["INSTRU_05"])
?? string.Empty,
INSTRU_06 =
Convert.ToString(
dr["INSTRU_06"])
?? string.Empty,
INSTRU_07 =
Convert.ToString(
dr["INSTRU_07"])
?? string.Empty,
INSTRU_08 =
Convert.ToString(
dr["INSTRU_08"])
?? string.Empty,
INSTRU_09 =
Convert.ToString(
dr["INSTRU_09"])
?? string.Empty,
INSTRU_10 =
Convert.ToString(
dr["INSTRU_10"])
?? string.Empty,
DIAS_PROTESTO =
Convert.ToString(
dr["DIAS_PROTESTO"])
?? string.Empty,
TIPO_DOC_COB =
Convert.ToString(
dr["TIPO_DOC_COB"])
?? string.Empty,
TIPO_ESP_DOC =
Convert.ToString(
dr["TIPO_ESP_DOC"])
?? string.Empty
};
}
private static void PreencherParametros(
SqlCommand cmd,
ModeloConvenioBoletos modelo)
{
cmd.Parameters.AddWithValue(
"@BANCO",
string.IsNullOrWhiteSpace(
modelo.BANCO)
? DBNull.Value
: modelo.BANCO);
cmd.Parameters.AddWithValue(
"@CARTEIRA",
string.IsNullOrWhiteSpace(
modelo.CARTEIRA)
? DBNull.Value
: modelo.CARTEIRA);
cmd.Parameters.AddWithValue(
"@CONVENIO",
string.IsNullOrWhiteSpace(
modelo.CONVENIO)
? DBNull.Value
: modelo.CONVENIO);
cmd.Parameters.AddWithValue(
"@AGENCIA",
string.IsNullOrWhiteSpace(
modelo.AGENCIA)
? DBNull.Value
: modelo.AGENCIA);
cmd.Parameters.AddWithValue(
"@CONTA",
string.IsNullOrWhiteSpace(
modelo.CONTA)
? DBNull.Value
: modelo.CONTA);
cmd.Parameters.AddWithValue(
"@NOME_CEDENTE",
string.IsNullOrWhiteSpace(
modelo.NOME_CEDENTE)
? DBNull.Value
: modelo.NOME_CEDENTE);
cmd.Parameters.AddWithValue(
"@LOCAL_PGTO",
string.IsNullOrWhiteSpace(
modelo.LOCAL_PGTO)
? DBNull.Value
: modelo.LOCAL_PGTO);
cmd.Parameters.AddWithValue(
"@INSTRU_01",
string.IsNullOrWhiteSpace(
modelo.INSTRU_01)
? DBNull.Value
: modelo.INSTRU_01);
cmd.Parameters.AddWithValue(
"@INSTRU_02",
string.IsNullOrWhiteSpace(
modelo.INSTRU_02)
? DBNull.Value
: modelo.INSTRU_02);
cmd.Parameters.AddWithValue(
"@INSTRU_03",
string.IsNullOrWhiteSpace(
modelo.INSTRU_03)
? DBNull.Value
: modelo.INSTRU_03);
cmd.Parameters.AddWithValue(
"@INSTRU_04",
string.IsNullOrWhiteSpace(
modelo.INSTRU_04)
? DBNull.Value
: modelo.INSTRU_04);
cmd.Parameters.AddWithValue(
"@INSTRU_05",
string.IsNullOrWhiteSpace(
modelo.INSTRU_05)
? DBNull.Value
: modelo.INSTRU_05);
cmd.Parameters.AddWithValue(
"@INSTRU_06",
string.IsNullOrWhiteSpace(
modelo.INSTRU_06)
? DBNull.Value
: modelo.INSTRU_06);
cmd.Parameters.AddWithValue(
"@INSTRU_07",
string.IsNullOrWhiteSpace(
modelo.INSTRU_07)
? DBNull.Value
: modelo.INSTRU_07);
cmd.Parameters.AddWithValue(
"@INSTRU_08",
string.IsNullOrWhiteSpace(
modelo.INSTRU_08)
? DBNull.Value
: modelo.INSTRU_08);
cmd.Parameters.AddWithValue(
"@INSTRU_09",
string.IsNullOrWhiteSpace(
modelo.INSTRU_09)
? DBNull.Value
: modelo.INSTRU_09);
cmd.Parameters.AddWithValue(
"@INSTRU_10",
string.IsNullOrWhiteSpace(
modelo.INSTRU_10)
? DBNull.Value
: modelo.INSTRU_10);
cmd.Parameters.AddWithValue(
"@DIAS_PROTESTO",
string.IsNullOrWhiteSpace(
modelo.DIAS_PROTESTO)
? DBNull.Value
: modelo.DIAS_PROTESTO);
cmd.Parameters.AddWithValue(
"@TIPO_DOC_COB",
string.IsNullOrWhiteSpace(
modelo.TIPO_DOC_COB)
? DBNull.Value
: modelo.TIPO_DOC_COB);
cmd.Parameters.AddWithValue(
"@TIPO_ESP_DOC",
string.IsNullOrWhiteSpace(
modelo.TIPO_ESP_DOC)
? DBNull.Value
: modelo.TIPO_ESP_DOC);
}
#endregion
}
}

424
DAL/DALLConvenioCartoes.cs Normal file
View File

@ -0,0 +1,424 @@
using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;
namespace DALL
{
public class DALLConvenioCartoes
{
private readonly string connectionString;
public DALLConvenioCartoes(string conexao)
{
connectionString = conexao;
}
#region CRUD
public bool Inserir(ModeloConvenioCartoes modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
INSERT INTO Convenio_cartoes
(
NOME,
COMIS_CRED,
COMIS_DEBT,
OP_CRED,
OP_DEBT,
LANCA_30,
CNPJ_OPERADORA,
tBand
)
VALUES
(
@NOME,
@COMIS_CRED,
@COMIS_DEBT,
@OP_CRED,
@OP_DEBT,
@LANCA_30,
@CNPJ_OPERADORA,
@tBand
)";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Alterar(ModeloConvenioCartoes modelo)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
UPDATE Convenio_cartoes
SET
CODIGO = @CODIGO,
NOME = @NOME,
COMIS_CRED = @COMIS_CRED,
COMIS_DEBT = @COMIS_DEBT,
OP_CRED = @OP_CRED,
OP_DEBT = @OP_DEBT,
LANCA_30 = @LANCA_30,
CNPJ_OPERADORA = @CNPJ_OPERADORA,
tBand = @tBand
WHERE ID_CONV_CARTOES =
@ID_CONV_CARTOES";
using SqlCommand cmd =
new(sql, conn);
PreencherParametros(
cmd,
modelo);
cmd.Parameters.AddWithValue(
"@CODIGO",
modelo.CODIGO);
cmd.Parameters.AddWithValue(
"@ID_CONV_CARTOES",
modelo.ID_CONV_CARTOES);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public bool Excluir(int id)
{
try
{
using SqlConnection conn =
new(connectionString);
string sql = @"
DELETE FROM Convenio_cartoes
WHERE ID_CONV_CARTOES =
@ID_CONV_CARTOES";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONV_CARTOES",
id);
conn.Open();
return cmd.ExecuteNonQuery() > 0;
}
catch
{
return false;
}
}
public ModeloConvenioCartoes? Carregar(int id)
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Convenio_cartoes
WHERE ID_CONV_CARTOES =
@ID_CONV_CARTOES";
using SqlCommand cmd =
new(sql, conn);
cmd.Parameters.AddWithValue(
"@ID_CONV_CARTOES",
id);
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
if (dr.Read())
{
return PreencherModelo(dr);
}
return null;
}
public List<ModeloConvenioCartoes> ListarOtimizado(
string? nome = null,
string? bandeira = null,
string? operadoraCredito = null,
string? operadoraDebito = null,
string? cnpj = null)
{
List<ModeloConvenioCartoes> lista = [];
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT *
FROM Convenio_cartoes
WHERE 1 = 1";
using SqlCommand cmd =
new();
cmd.Connection = conn;
if (!string.IsNullOrWhiteSpace(
nome))
{
sql += @"
AND NOME LIKE
@NOME";
cmd.Parameters.AddWithValue(
"@NOME",
"%" + nome + "%");
}
if (!string.IsNullOrWhiteSpace(
bandeira))
{
sql += @"
AND tBand LIKE
@tBand";
cmd.Parameters.AddWithValue(
"@tBand",
"%" + bandeira + "%");
}
if (!string.IsNullOrWhiteSpace(
operadoraCredito))
{
sql += @"
AND OP_CRED LIKE
@OP_CRED";
cmd.Parameters.AddWithValue(
"@OP_CRED",
"%" + operadoraCredito + "%");
}
if (!string.IsNullOrWhiteSpace(
operadoraDebito))
{
sql += @"
AND OP_DEBT LIKE
@OP_DEBT";
cmd.Parameters.AddWithValue(
"@OP_DEBT",
"%" + operadoraDebito + "%");
}
if (!string.IsNullOrWhiteSpace(
cnpj))
{
sql += @"
AND CNPJ_OPERADORA LIKE
@CNPJ_OPERADORA";
cmd.Parameters.AddWithValue(
"@CNPJ_OPERADORA",
"%" + cnpj + "%");
}
sql += @"
ORDER BY
ID_CONV_CARTOES DESC";
cmd.CommandText = sql;
conn.Open();
using SqlDataReader dr =
cmd.ExecuteReader();
while (dr.Read())
{
lista.Add(
PreencherModelo(dr));
}
return lista;
}
#endregion
#region DASHBOARD
public DataTable Dashboard()
{
using SqlConnection conn =
new(connectionString);
string sql = @"
SELECT
COUNT(*) AS TOTAL_CONVENIOS
FROM Convenio_cartoes";
using SqlCommand cmd =
new(sql, conn);
using SqlDataAdapter da =
new(cmd);
DataTable dt = new();
da.Fill(dt);
return dt;
}
#endregion
#region HELPERS
private static ModeloConvenioCartoes
PreencherModelo(
SqlDataReader dr)
{
return new ModeloConvenioCartoes
{
ID_CONV_CARTOES =
Convert.ToInt32(
dr["ID_CONV_CARTOES"]),
CODIGO =
Convert.ToString(
dr["CODIGO"])
?? string.Empty,
NOME =
Convert.ToString(
dr["NOME"])
?? string.Empty,
COMIS_CRED =
Convert.ToString(
dr["COMIS_CRED"])
?? string.Empty,
COMIS_DEBT =
Convert.ToString(
dr["COMIS_DEBT"])
?? string.Empty,
OP_CRED =
Convert.ToString(
dr["OP_CRED"])
?? string.Empty,
OP_DEBT =
Convert.ToString(
dr["OP_DEBT"])
?? string.Empty,
LANCA_30 =
Convert.ToString(
dr["LANCA_30"])
?? string.Empty,
CNPJ_OPERADORA =
Convert.ToString(
dr["CNPJ_OPERADORA"])
?? string.Empty,
TBAND =
Convert.ToString(
dr["tBand"])
?? string.Empty
};
}
private static void PreencherParametros(
SqlCommand cmd,
ModeloConvenioCartoes modelo)
{
cmd.Parameters.AddWithValue(
"@NOME",
string.IsNullOrWhiteSpace(
modelo.NOME)
? DBNull.Value
: modelo.NOME);
cmd.Parameters.AddWithValue(
"@COMIS_CRED",
string.IsNullOrWhiteSpace(
modelo.COMIS_CRED)
? DBNull.Value
: modelo.COMIS_CRED);
cmd.Parameters.AddWithValue(
"@COMIS_DEBT",
string.IsNullOrWhiteSpace(
modelo.COMIS_DEBT)
? DBNull.Value
: modelo.COMIS_DEBT);
cmd.Parameters.AddWithValue(
"@OP_CRED",
string.IsNullOrWhiteSpace(
modelo.OP_CRED)
? DBNull.Value
: modelo.OP_CRED);
cmd.Parameters.AddWithValue(
"@OP_DEBT",
string.IsNullOrWhiteSpace(
modelo.OP_DEBT)
? DBNull.Value
: modelo.OP_DEBT);
cmd.Parameters.AddWithValue(
"@LANCA_30",
string.IsNullOrWhiteSpace(
modelo.LANCA_30)
? DBNull.Value
: modelo.LANCA_30);
cmd.Parameters.AddWithValue(
"@CNPJ_OPERADORA",
string.IsNullOrWhiteSpace(
modelo.CNPJ_OPERADORA)
? DBNull.Value
: modelo.CNPJ_OPERADORA);
cmd.Parameters.AddWithValue(
"@tBand",
string.IsNullOrWhiteSpace(
modelo.TBAND)
? DBNull.Value
: modelo.TBAND);
}
#endregion
}
}

40
UI/ArquivosAuxiliares/Triggers/ClienteEnderecosTriggers.sql Normal file
View File

@ -0,0 +1,40 @@
CREATE OR ALTER TRIGGER TR_ClientesEnderecos_GerarCodigo
ON Clientes_enderecos
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT @UltimoNumero =
ISNULL(
MAX(
CAST(
REPLACE(CODIGO, 'END', '')
AS INT)
),
99)
FROM Clientes_enderecos
WHERE CODIGO IS NOT NULL;
;WITH Numerados AS
(
SELECT
ID_COD_CLIENTE_END,
ROW_NUMBER() OVER (ORDER BY ID_COD_CLIENTE_END) AS Linha
FROM inserted
)
UPDATE C
SET CODIGO =
'END' +
RIGHT(
'0000' +
CAST(@UltimoNumero + N.Linha AS VARCHAR),
4
)
FROM Clientes_enderecos C
INNER JOIN Numerados N
ON C.ID_COD_CLIENTE_END = N.ID_COD_CLIENTE_END;
END
GO

48
UI/ArquivosAuxiliares/Triggers/ContaDepositoTrigger.sql Normal file
View File

@ -0,0 +1,48 @@
CREATE OR ALTER TRIGGER TR_ContasDepositos_GerarCodigo
ON Contas_depositos
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT
@UltimoNumero =
ISNULL(
MAX(
TRY_CAST(
REPLACE(CODIGO, 'CD', '')
AS INT)
),
99)
FROM Contas_depositos
WHERE CODIGO LIKE 'CD%';
;WITH Numerados AS
(
SELECT
ID_COD_CONTA_DEPO,
ROW_NUMBER() OVER
(
ORDER BY ID_COD_CONTA_DEPO
) AS Linha
FROM inserted
)
UPDATE C
SET
CODIGO =
'CD' +
RIGHT(
'0000' +
CAST(
@UltimoNumero + N.Linha
AS VARCHAR
),
4)
FROM Contas_depositos C
INNER JOIN Numerados N
ON C.ID_COD_CONTA_DEPO =
N.ID_COD_CONTA_DEPO;
END
GO

40
UI/ArquivosAuxiliares/Triggers/ContasContas.sql Normal file
View File

@ -0,0 +1,40 @@
CREATE OR ALTER TRIGGER TR_ContasContas_GerarCodigo
ON Contas_contas
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT
@UltimoNumero =
ISNULL(
MAX(
TRY_CAST(CODIGO AS INT)
),
99)
FROM Contas_contas
WHERE ISNUMERIC(CODIGO) = 1;
;WITH Numerados AS
(
SELECT
ID_CONTAS_CONTAS,
ROW_NUMBER() OVER
(
ORDER BY ID_CONTAS_CONTAS
) AS Linha
FROM inserted
)
UPDATE C
SET
CODIGO =
CAST(
@UltimoNumero + N.Linha
AS VARCHAR)
FROM Contas_contas C
INNER JOIN Numerados N
ON C.ID_CONTAS_CONTAS = N.ID_CONTAS_CONTAS;
END
GO

40
UI/ArquivosAuxiliares/Triggers/ContasTrigger.sql Normal file
View File

@ -0,0 +1,40 @@
CREATE OR ALTER TRIGGER TR_Contas_GerarCodigo
ON Contas
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT
@UltimoNumero =
ISNULL(
MAX(
TRY_CAST(CODIGO AS INT)
),
99)
FROM Contas
WHERE ISNUMERIC(CODIGO) = 1;
;WITH Numerados AS
(
SELECT
ID_CONTAS,
ROW_NUMBER() OVER
(
ORDER BY ID_CONTAS
) AS Linha
FROM inserted
)
UPDATE C
SET
CODIGO =
CAST(
@UltimoNumero + N.Linha
AS VARCHAR)
FROM Contas C
INNER JOIN Numerados N
ON C.ID_CONTAS = N.ID_CONTAS;
END
GO

48
UI/ArquivosAuxiliares/Triggers/ConvenioBoletosTrigger.sql Normal file
View File

@ -0,0 +1,48 @@
CREATE OR ALTER TRIGGER TR_ConvenioBoletos_GerarCodigo
ON Convenio_boletos
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT
@UltimoNumero =
ISNULL(
MAX(
TRY_CAST(
REPLACE(CODIGO, 'CB', '')
AS INT)
),
99)
FROM Convenio_boletos
WHERE CODIGO LIKE 'CB%';
;WITH Numerados AS
(
SELECT
ID_CONVENIO_BOLETOS,
ROW_NUMBER() OVER
(
ORDER BY ID_CONVENIO_BOLETOS
) AS Linha
FROM inserted
)
UPDATE C
SET
CODIGO =
'CB' +
RIGHT(
'0000' +
CAST(
@UltimoNumero + N.Linha
AS VARCHAR
),
4)
FROM Convenio_boletos C
INNER JOIN Numerados N
ON C.ID_CONVENIO_BOLETOS =
N.ID_CONVENIO_BOLETOS;
END
GO

48
UI/ArquivosAuxiliares/Triggers/ConvenioCartoesTrigger.sql Normal file
View File

@ -0,0 +1,48 @@
CREATE OR ALTER TRIGGER TR_ConvenioCartoes_GerarCodigo
ON Convenio_cartoes
AFTER INSERT
AS
BEGIN
SET NOCOUNT ON;
DECLARE @UltimoNumero INT;
SELECT
@UltimoNumero =
ISNULL(
MAX(
TRY_CAST(
REPLACE(CODIGO, 'CC', '')
AS INT)
),
99)
FROM Convenio_cartoes
WHERE CODIGO LIKE 'CC%';
;WITH Numerados AS
(
SELECT
ID_CONV_CARTOES,
ROW_NUMBER() OVER
(
ORDER BY ID_CONV_CARTOES
) AS Linha
FROM inserted
)
UPDATE C
SET
CODIGO =
'CC' +
RIGHT(
'0000' +
CAST(
@UltimoNumero + N.Linha
AS VARCHAR
),
4)
FROM Convenio_cartoes C
INNER JOIN Numerados N
ON C.ID_CONV_CARTOES =
N.ID_CONV_CARTOES;
END
GO