/// <summary>
/// Obtém a descrição da regra de natureza de operação.
/// </summary>
public string ObtemDescricao(GDA.GDASession session, uint idRegraNaturezaOperacao)
{
StringBuilder desc = new StringBuilder();
string where = "idRegraNaturezaOperacao=" + idRegraNaturezaOperacao;
uint?idLoja = ObtemValorCampo <uint?>(session, "idLoja", where);
uint?idTipoCliente = ObtemValorCampo <uint?>(session, "idTipoCliente", where);
uint?idGrupoProd = ObtemValorCampo <uint?>(session, "idGrupoProd", where);
uint?idSubgrupoProd = ObtemValorCampo <uint?>(session, "idSubgrupoProd", where);
if (idLoja > 0)
{
desc.AppendFormat("Loja: {0} / ", LojaDAO.Instance.GetNome(session, idLoja.Value));
}
if (idTipoCliente > 0)
{
desc.AppendFormat("Tipo Cliente: {0} / ", TipoClienteDAO.Instance.GetNome(session, idTipoCliente.Value));
}
if (idGrupoProd > 0)
{
desc.AppendFormat("Grupo: {0} / ", GrupoProdDAO.Instance.GetDescricao(session, (int)idGrupoProd.Value));
}
if (idSubgrupoProd > 0)
{
desc.AppendFormat("Subgrupo: {0} / ", SubgrupoProdDAO.Instance.GetDescricao(session, (int)idSubgrupoProd.Value));
}
return(desc.ToString().TrimEnd('/', ' '));
}
/// <summary>
/// Retorna as variáveis do arquivo do CalcEngine.
/// </summary>
/// <param name="session"></param>
/// <param name="idArquivoCalcEngine"></param>
/// <param name="buscarAlturaLargura"></param>
public List <ArquivoCalcEngineVariavel> ObtemPeloIdArquivoCalcEngine(GDA.GDASession session, uint idArquivoCalcEngine, bool buscarAlturaLargura)
{
return(objPersistence.LoadData(session, @"SELECT acv.* FROM arquivo_calcengine_variavel acv
WHERE acv.idArquivoCalcEngine=" + idArquivoCalcEngine +
(!buscarAlturaLargura ? " AND acv.variavelCalcEngine NOT IN ('Altura', 'Largura') " : "") +
" ORDER BY VariavelCalcEngine ASC"));
}
/// <summary>
/// Atualiza a rentabilidade do custo do produto da nota fiscal.
/// </summary>
/// <param name="idProdNfCusto"></param>
/// <param name="percentualRentabilidade">Percentual da rentabilidade.</param>
/// <param name="rentabilidadeFinanceira">Rentabilidade financeira.</param>
public void AtualizarRentabilidade(GDA.GDASession sessao,
int idProdNfCusto, decimal percentualRentabilidade, decimal rentabilidadeFinanceira)
{
objPersistence.ExecuteCommand(sessao, "UPDATE produto_nf_custo SET PercentualRentabilidade=?percentual, RentabilidadeFinanceira=?rentabilidade WHERE IdProdNfCusto=?id",
new GDA.GDAParameter("?percentual", percentualRentabilidade),
new GDA.GDAParameter("?rentabilidade", rentabilidadeFinanceira),
new GDA.GDAParameter("?id", idProdNfCusto));
}
/// <summary>
/// Atualiza a rentabilidade do ambiente do pedido..
/// </summary>
/// <param name="idAmbientePedido"></param>
/// <param name="percentualRentabilidade">Percentual da rentabilidade.</param>
/// <param name="rentabilidadeFinanceira">Rentabilidade financeira.</param>
public void AtualizarRentabilidade(GDA.GDASession sessao,
uint idAmbientePedido, decimal percentualRentabilidade, decimal rentabilidadeFinanceira)
{
objPersistence.ExecuteCommand(sessao, "UPDATE ambiente_pedido SET PercentualRentabilidade=?percentual, RentabilidadeFinanceira=?rentabilidade WHERE IdAmbientePedido=?id",
new GDA.GDAParameter("?percentual", percentualRentabilidade),
new GDA.GDAParameter("?rentabilidade", rentabilidadeFinanceira),
new GDA.GDAParameter("?id", idAmbientePedido));
}
/// <summary>
/// Apaga os registros associados com o produto da nota fiscal.
/// </summary>
/// <param name="sessao"></param>
/// <param name="idProdNf"></param>
public void ApagarPorProdutoNf(GDA.GDASession sessao, uint idProdNf)
{
// Apaga os registro de rentabilidade
objPersistence.ExecuteCommand(sessao,
"DELETE FROM produto_nf_custo_rentabilidade WHERE IdProdNfCusto IN (SELECT IdProdNfCusto FROM produto_nf_custo pnc WHERE pnc.IdProdNf=?id)",
new GDA.GDAParameter("?id", idProdNf));
objPersistence.ExecuteCommand(sessao, "DELETE FROM produto_nf_custo WHERE IdProdNf=?id", new GDA.GDAParameter("?id", idProdNf));
}
/// <summary>
/// Recupera os custos do produto da nota fiscal.
/// </summary>
/// <param name="sessao"></param>
/// <param name="idProdNf"></param>
/// <returns></returns>
public IEnumerable <ProdutoNfCusto> ObterCustosPorProdutoNotaFiscal(GDA.GDASession sessao, uint idProdNf)
{
return(objPersistence.LoadData(sessao,
@"SELECT pnc.*, pnEntrada.AliqIpi AS AliqIpiCompra, pnEntrada.AliqIcms AS AliqIcmsCompra
FROM produto_nf_custo pnc
LEFT JOIN produtos_nf pnEntrada ON (pnc.IdProdNfEntrada=pnEntrada.IdProdNf)
WHERE IdProdNf=?id",
new GDA.GDAParameter("?id", idProdNf)).ToList());
}
private RegraNaturezaOperacao BuscaRegra(GDA.GDASession session, uint?idNf, NotaFiscal.TipoDoc?tipoDocumentoNotaFiscal, uint?idLoja, uint?idTipoCliente,
uint?idGrupoProd, uint?idSubgrupoProd, uint?idCorVidro, uint?idCorAluminio, uint?idCorFerragem, float?espessura, bool gerandoNfSaida, string ufDestino)
{
// Só busca a regra de natureza de operação para notas fiscais de saída
if (!gerandoNfSaida &&
((tipoDocumentoNotaFiscal == null &&
(idNf.GetValueOrDefault() == 0 || NotaFiscalDAO.Instance.GetTipoDocumento(session, idNf.GetValueOrDefault()) != (int)NotaFiscal.TipoDoc.Saída)) ||
tipoDocumentoNotaFiscal != NotaFiscal.TipoDoc.Saída))
{
return(null);
}
// Faz a ordenação decrescente para considerar o item que tiver o valor preenchido
// nos campos ser retornado (no lugar de um item mais geral - com menos campos preenchidos)
StringBuilder sql = new StringBuilder(@"
select * from regra_natureza_operacao
where (UfDest LIKE ?ufDestino OR UfDest IS NULL) {0}
order by espessura desc, idCorFerragem desc, idCorAluminio desc, idCorVidro desc,
idSubgrupoProd desc, idGrupoProd desc, idTipoCliente desc, idLoja desc
limit 1");
// Considera os filtros para busca
StringBuilder where = new StringBuilder();
if (idLoja > 0)
{
where.AppendFormat(" and coalesce(idLoja, {0})={0}", idLoja);
}
if (idTipoCliente > 0)
{
where.AppendFormat(" and coalesce(idTipoCliente, {0})={0}", idTipoCliente);
}
if (idGrupoProd > 0)
{
where.AppendFormat(" and coalesce(idGrupoProd, {0})={0}", idGrupoProd);
}
if (idSubgrupoProd > 0)
{
where.AppendFormat(" and coalesce(idSubgrupoProd, {0})={0}", idSubgrupoProd);
}
// Chamado 13565.
// Havia uma regra cadastrada no sistema com e sem subgrupo, a regra sem subgrupo estava considerando
// a regra com subgrupo, incluímos esta condição no sql (caso não tenha código do subgrupo) para que
// não seja buscada a regra com subgrupo.
else
{
where.AppendFormat(" AND COALESCE(idSubgrupoProd, 0)=0");
}
if (idCorVidro > 0)
{
where.AppendFormat(" and coalesce(idCorVidro, {0})={0}", idCorVidro);
}
if (idCorAluminio > 0)
{
where.AppendFormat(" and coalesce(idCorAluminio, {0})={0}", idCorAluminio);
}
if (idCorFerragem > 0)
{
where.AppendFormat(" and coalesce(idCorFerragem, {0})={0}", idCorFerragem);
}
if (espessura > 0)
{
where.AppendFormat(" and coalesce(espessura, {0})={0}", espessura.ToString().Replace(",", "."));
}
// Retorna apenas o primeiro item do retorno da consulta, se houver
var itens = objPersistence.LoadData(session, string.Format(sql.ToString(), where.ToString()), new GDAParameter("?ufDestino", "%" + ufDestino + "%")).ToList();
return(itens.Count > 0 ? itens[0] : null);
}
public object ExecuteScalar(GDASession session, GDAStoredProcedure procedure)
{
IDbConnection conn = CreateConnection(session);
IDbCommand cmd = CreateCommand(session, conn);
object valueReturn = null;
try
{
procedure.Prepare(cmd, UserProvider);
if (session == null && conn.State != ConnectionState.Open)
{
try
{
conn.Open();
}
catch (Exception ex)
{
throw new GDAException(ex);
}
GDAConnectionManager.NotifyConnectionOpened(conn);
}
SendMessageDebugTrace(cmd.CommandText);
try
{
using (var executionHandler = Diagnostics.GDATrace.CreateExecutionHandler(cmd))
try
{
valueReturn = cmd.ExecuteScalar();
}
catch (Exception ex)
{
executionHandler.Fail(ex);
throw ex;
}
}
catch (Exception ex)
{
throw new GDAException("StoredProcedure: " + cmd.CommandText + "; --> " + ex.Message, ex);
}
for (int i = 0; i < cmd.Parameters.Count; i++)
{
procedure[i] = ((IDbDataParameter)cmd.Parameters[i]).Value;
}
}
finally
{
try
{
cmd.Dispose();
cmd = null;
}
finally
{
if (session == null)
{
conn.Close();
conn.Dispose();
}
}
}
return(valueReturn);
}
/// <summary>
/// Salva os dados na base. Primeiro verifica se o registro existe, se existir ele ser� atualizado
/// sen�o ele ser� inserido.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="model">Model contendo os dados a serem salvos.</param>
/// <returns>A chave do registro inserido ou 0 se ele for atualizado.</returns>
/// <exception cref="GDAReferenceDAONotFoundException"></exception>
/// <exception cref="GDAException">Se o tipo de dados utilizado n�o possuir chaves.</exception>
/// <exception cref="GDAConditionalClauseException">Parameters do not exist to build the conditional clause.</exception>
public static uint Save(GDASession session, object model)
{
return(GetDAO(model).InsertOrUpdate(session, model));
}
/// <summary>
/// Remove o registro da base de dados.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="model">Model contendo os dados a serem removidos.</param>
/// <returns>N�mero de linhas afetadas.</returns>
/// <exception cref="GDAReferenceDAONotFoundException"></exception>
/// <exception cref="GDAConditionalClauseException">Parameters do not exist to contruir the conditional clause.</exception>
/// <exception cref="GDAException"></exception>
public static int Delete(GDASession session, object model)
{
return(GetDAO(model).Delete(session, model));
}
/// <summary>
/// Busca os dados relacionados com a consulta submetida.
/// </summary>
/// <param name="session">Sessão utilizada para a execução do comando.</param>
/// <param name="query">Consulta.</param>
/// <returns></returns>
public GDADataRecordCursor <Model> SelectToDataRecord(GDASession session, IQuery query)
{
query.ReturnTypeQuery = typeof(Model);
return(CurrentPersistenceObject.SelectToDataRecord(session, query));
}
/// <summary>
/// Executa uma consulta que retorna somente um campo.
/// </summary>
/// <param name="session">Sessão utilizada para a execução do comando.</param>
/// <param name="sqlQuery">Consulta.</param>
/// <returns></returns>
public object ExecuteScalar(GDASession session, string sqlQuery)
{
return(ExecuteScalar(session, sqlQuery, null));
}
public uint?BuscaNaturezaOperacao(GDA.GDASession session, uint?idNf, NotaFiscal.TipoDoc?tipoDocumentoNotaFiscal, uint?idLoja, uint?idCliente,
int?idProd, bool gerandoNfSaida)
{
// Preenche as variáveis que são utilizadas nos métodos abaixo
uint?idTipoCliente = idCliente > 0 ?
ClienteDAO.Instance.ObtemValorCampo <uint?>(session, "idTipoCliente", "id_Cli=" + idCliente) :
null;
uint?idGrupoProd = idProd > 0 ?
(uint?)ProdutoDAO.Instance.ObtemIdGrupoProd(session, idProd.Value) :
null;
uint?idSubgrupoProd = (uint?)(idProd > 0 ?
ProdutoDAO.Instance.ObtemIdSubgrupoProd(session, idProd.Value) :
null);
uint?idCorVidro = (uint?)(idProd > 0 ?
ProdutoDAO.Instance.ObtemIdCorVidro(session, idProd.Value) :
null);
uint?idCorAluminio = (idProd > 0 ?
ProdutoDAO.Instance.ObtemIdCorAluminio(session, idProd.Value) :
null);
uint?idCorFerragem = (idProd > 0 ?
ProdutoDAO.Instance.ObtemIdCorFerragem(session, idProd.Value) :
null);
float?espessura = idProd > 0 ?
ProdutoDAO.Instance.ObtemEspessura(session, idProd.Value) :
(float?)null;
var dados = MvaProdutoUfDAO.Instance.ObterDadosParaBuscar(session, idLoja.Value, null, idCliente, true);
// Busca a regra de natureza de operação que será aplicada
var regra = BuscaRegra(session, idNf, tipoDocumentoNotaFiscal, idLoja, idTipoCliente, idGrupoProd, idSubgrupoProd, idCorVidro,
idCorAluminio, idCorFerragem, espessura, gerandoNfSaida, dados.UfDestino);
// Indica que a regra não foi encontrada
if (regra == null)
{
return(null);
}
bool prodRevenda = !ProdutoDAO.Instance.IsProdutoVenda(session, idProd.Value);
var mva = idProd > 0 ? MvaProdutoUfDAO.Instance.ObterMvaPorProduto(session, idProd.Value, idLoja.Value, dados.UfOrigem,
dados.UfDestino, dados.Simples, dados.TipoCliente, true) : 0;
// O produto consulta as regras de natureza de operação de ST apenas se
// o MVA relativo à movimentação entre as UF
bool possuiSt = mva > 0;
// Verifica se as UFs são iguais (origem e destino)
if (string.Equals(dados.UfOrigem, dados.UfDestino, StringComparison.InvariantCultureIgnoreCase))
{
return((uint?)(!possuiSt ?
(prodRevenda ? regra.IdNaturezaOperacaoRevIntra : regra.IdNaturezaOperacaoProdIntra) :
(prodRevenda ? regra.IdNaturezaOperacaoRevStIntra : regra.IdNaturezaOperacaoProdStIntra)));
}
else
{
return((uint?)(!possuiSt ?
(prodRevenda ? regra.IdNaturezaOperacaoRevInter : regra.IdNaturezaOperacaoProdInter) :
(prodRevenda ? regra.IdNaturezaOperacaoRevStInter : regra.IdNaturezaOperacaoProdStInter)));
}
}
/// <summary>
/// Verifica se o valor da propriedade informada existe no banco de dados.
/// </summary>
/// <param name="session">Sess�o de conex�o que ser� usada na verifica��o.</param>
/// <param name="mode">Modo de valida��o.</param>
/// <param name="propertyName">Nome da propriedade que ser� verificada.</param>
/// <param name="propertyValue">Valor da propriedade que ser� verificada.</param>
/// <param name="parent">Elemento que cont�m a propriedade</param>
/// <returns>True caso existir.</returns>
public static bool CheckExist(GDASession session, ValidationMode mode, string propertyName, object propertyValue, object parent)
{
return(GetDAO(parent).CheckExist(session, mode, propertyName, propertyValue, parent));
}
/// <summary>
/// Recupera a quantidade de registros da tabela no banco.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <returns>Quantidade de registro encontrados com base na consulta.</returns>
public static long Count <Model>(GDASession session) where Model : new()
{
return(GetDAO <Model>().Count(session));
}
/// <summary>
/// Carrega os dados com base na consulta informada.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <returns></returns>
public static GDAList <Model> Select <Model>(GDASession session) where Model : new()
{
return(GetDAO <Model>().Select(session));
}
/// <summary>
/// Executa a Stored Procedure e recupera os dados do resultado.
/// </summary>
/// <param name="session">Sessão onde será executada a consulta.</param>
/// <param name="procedure">Procedure que será executada.</param>
/// <returns></returns>
public GDADataRecordCursor LoadResult(GDASession session, GDAStoredProcedure procedure)
{
return(new GDADataRecordCursor(GetLoadResultCursorParameters(session, procedure)));
}
/// <summary>
/// Executa a consulta e recupera o dados do resultado.
/// </summary>
/// <param name="session">Sessão onde será executada a consulta.</param>
/// <param name="commandType">Tipo de comando.</param>
/// <param name="commandTimeout"></param>
/// <param name="paging"></param>
/// <param name="sqlQuery">Consulta.</param>
/// <param name="parameters">Parametros para a consulta.</param>
/// <returns></returns>
public GDADataRecordCursor LoadResult(GDASession session, CommandType commandType, int commandTimeout, string sqlQuery, InfoPaging paging, params GDAParameter[] parameters)
{
return(new GDADataRecordCursor(GetLoadResultCursorParameters(session, commandType, commandTimeout, sqlQuery, paging, parameters)));
}
/// <summary>
/// Executa a consulta e recupera o dados do resultado.
/// </summary>
/// <param name="session">Sessão onde será executada a consulta.</param>
/// <param name="sqlQuery">Consulta.</param>
/// <param name="parameters">Parametros para a consulta.</param>
/// <returns></returns>
public GDADataRecordCursor LoadResult(GDASession session, string sqlQuery, params GDAParameter[] parameters)
{
return(new GDADataRecordCursor(GetLoadResultCursorParameters(session, CommandType.Text, -1, sqlQuery, null, parameters)));
}
public uint?BuscaNaturezaOperacao(GDA.GDASession session, uint idNf, uint?idLoja, uint?idCliente, int?idProd)
{
return(BuscaNaturezaOperacao(session, idNf, null, idLoja, idCliente, idProd, false));
}
public uint?BuscaNaturezaOperacao(GDA.GDASession session, uint idNf, NotaFiscal.TipoDoc tipoDocumentoNotaFiscal, uint idLoja, uint?idCliente,
int?idProd)
{
return(BuscaNaturezaOperacao(session, idNf, tipoDocumentoNotaFiscal, idLoja, idCliente, idProd, false));
}
/// <summary>
/// Executa uma consulta que retorna somente um campo.
/// </summary>
/// <param name="session">Sessão utilizada para a execução do comando.</param>
/// <param name="sqlQuery">Consulta.</param>
/// <param name="parameters"></param>
/// <returns></returns>
public object ExecuteScalar(GDASession session, CommandType commandType, int commandTimeout, string sqlQuery, params GDAParameter[] parameters)
{
object returnValue;
IDbConnection conn = CreateConnection(session);
IDbCommand cmd = CreateCommand(session, conn);
try
{
if (parameters != null)
{
for (int i = 0; i < parameters.Length; i++)
{
string newName = (parameters[i].ParameterName[0] != '?' ? parameters[i].ParameterName : UserProvider.ParameterPrefix + parameters[i].ParameterName.Substring(1) + UserProvider.ParameterSuffix);
sqlQuery = sqlQuery.Replace(parameters[i].ParameterName, newName);
cmd.Parameters.Add(GDA.Helper.GDAHelper.ConvertGDAParameter(cmd, parameters[i], UserProvider));
}
}
cmd.CommandText = sqlQuery;
cmd.CommandType = commandType;
cmd.CommandTimeout = commandTimeout;
if (session == null && conn.State != ConnectionState.Open)
{
try
{
conn.Open();
}
catch (Exception ex)
{
throw new GDAException(ex);
}
GDAConnectionManager.NotifyConnectionOpened(conn);
}
try
{
SendMessageDebugTrace(cmd.CommandText);
using (var executionHandler = Diagnostics.GDATrace.CreateExecutionHandler(cmd))
try
{
returnValue = cmd.ExecuteScalar();
}
catch (Exception ex)
{
executionHandler.Fail(ex);
throw ex;
}
if (returnValue != DBNull.Value && returnValue != null)
{
SendMessageDebugTrace("Return: " + returnValue.ToString());
}
else
{
returnValue = null;
SendMessageDebugTrace("Return: null");
}
}
catch (Exception ex)
{
throw new GDAException(ex);
}
}
finally
{
try
{
cmd.Dispose();
cmd = null;
}
finally
{
if (session == null)
{
conn.Close();
conn.Dispose();
}
}
}
return(returnValue);
}
public void DeleteByPecaProjMod(GDA.GDASession session, int idPecaProjMod)
{
string sql = "delete from flag_arq_mesa_peca_projeto_modelo where idPecaProjMod=" + idPecaProjMod;
objPersistence.ExecuteCommand(session, sql);
}
/// <summary>
/// Executa uma consulta que retorna somente um campo.
/// </summary>
/// <param name="session">Sessão utilizada para a execução do comando.</param>
/// <param name="sqlQuery">Consulta.</param>
/// <param name="parameters"></param>
/// <returns></returns>
public object ExecuteScalar(GDASession session, string sqlQuery, params GDAParameter[] parameters)
{
return(ExecuteScalar(session, CommandType.Text, GDASession.DefaultCommandTimeout, sqlQuery, parameters));
}
/// <summary>
/// Inseri o registro no BD.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="model">Model contendo os dados a serem inseridos.</param>
/// <param name="propertiesNamesInsert">Nome das propriedades separados por virgula, que ser�o inseridos no comando.</param>
/// <returns>Chave gerada no processo.</returns>
/// <exception cref="GDAException"></exception>
/// <exception cref="GDAReferenceDAONotFoundException"></exception>
public static uint Insert(GDASession session, object model, string propertiesNamesInsert)
{
return(GetDAO(model).Insert(session, model, propertiesNamesInsert));
}
/// <summary>
/// Executa comandos sql.
/// </summary>
/// <param name="session">Sessão para execução do comando.</param>
/// <param name="commandType">Tipo do comando a ser executado.</param>
/// <param name="commandTimeout">commandTimeout</param>
/// <param name="sqlQuery">Causa sql a ser executada.</param>
/// <param name="parameters">Parametros a serem passados para o comando.</param>
/// <returns>Número de linhas afetadas.</returns>
/// <exception cref="ArgumentNullException">sqlQuery</exception>
/// <exception cref="ArgumentException">sqlQuery cannot empty.</exception>
public int ExecuteCommand(GDASession session, CommandType commandType, int commandTimeout, string sqlQuery, params GDAParameter[] parameters)
{
if (sqlQuery == null)
{
throw new ArgumentNullException("sqlQuery");
}
else if (sqlQuery == "")
{
throw new ArgumentException("sqlQuery cannot empty.");
}
int valueReturn = 0;
IDbConnection conn = CreateConnection(session);
IDbCommand command = CreateCommand(session, conn);
try
{
SendMessageDebugTrace(sqlQuery);
string newParameterName = null;
if (parameters != null)
{
for (int i = 0; i < parameters.Length; i++)
{
newParameterName = parameters[i].ParameterName.Replace("?", UserProvider.ParameterPrefix) + UserProvider.ParameterSuffix;
sqlQuery = sqlQuery.Replace(parameters[i].ParameterName, newParameterName);
parameters[i].ParameterName = newParameterName;
IDbDataParameter p = GDA.Helper.GDAHelper.ConvertGDAParameter(command, parameters[i], UserProvider);
command.Parameters.Add(p);
}
}
command.CommandText = sqlQuery;
command.CommandType = commandType;
command.CommandTimeout = commandTimeout;
if (session == null && conn.State != ConnectionState.Open)
{
try
{
conn.Open();
}
catch (Exception ex)
{
throw new GDAException(ex);
}
GDAConnectionManager.NotifyConnectionOpened(conn);
}
try
{
SendMessageDebugTrace(command.CommandText);
using (var executionHandler = Diagnostics.GDATrace.CreateExecutionHandler(command))
try
{
executionHandler.RowsAffects = valueReturn = command.ExecuteNonQuery();
}
catch (Exception ex)
{
executionHandler.Fail(ex);
throw ex;
}
SendMessageDebugTrace("Return: " + valueReturn.ToString());
}
catch (Exception ex)
{
throw new GDAException("SqlQuery: " + sqlQuery + "; --> " + ex.Message, ex);
}
for (int i = 0; i < command.Parameters.Count; i++)
{
parameters[i].Value = ((IDbDataParameter)command.Parameters[i]).Value;
}
}
finally
{
try
{
command.Dispose();
command = null;
}
finally
{
if (session == null)
{
conn.Close();
conn.Dispose();
}
}
}
return(valueReturn);
}
/// <summary>
/// Recupera os ambientes do pedido para a rentabilidade.
/// </summary>
/// <param name="sessao"></param>
/// <param name="idPedido"></param>
/// <returns></returns>
public IList <AmbientePedido> ObterAmbientesParaRentabilidade(GDA.GDASession sessao, uint idPedido)
{
return(objPersistence.LoadData(sessao, "SELECT * FROM ambiente_pedido WHERE IdPedido=?id", new GDAParameter("?id", idPedido)).ToList());
}
/// <summary>
/// Inseri o registro no BD.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="model">Model contendo os dados a serem inseridos.</param>
/// <returns>Chave gerada no processo.</returns>
/// <exception cref="GDAException"></exception>
/// <exception cref="GDAReferenceDAONotFoundException"></exception>
public static uint Insert(GDASession session, object model)
{
return(GetDAO(model).Insert(session, model));
}
private string Sql(GDA.GDASession session, uint idAcertoCheque, uint idFunc, uint idCliente, string nomeCliente, string dataIni,
string dataFim, bool?chequesProprios, bool chequesCaixaDiario, bool selecionar)
{
StringBuilder criterio = new StringBuilder();
StringBuilder sql = new StringBuilder("select ");
sql.Append(selecionar ? @"a.*, f.Nome as NomeFunc, cli.nome as nomeCliente, temp.FormasPagto, '$$$' as Criterio,
(select count(*) from item_acerto_cheque iac inner join cheques c on (iac.idCheque=c.idCheque) where c.tipo=1 and iac.idAcertoCheque=a.idAcertoCheque" +
(chequesCaixaDiario ? " and c.movcaixadiario " : "") + ")>0 " +
"as chequesProprios" : "Count(*)");
sql.Append(@"
from acerto_cheque a
left join funcionario f on (a.idFunc=f.idFunc)
left join cliente cli On (a.idCliente=cli.id_cli)
left join (
select pac.idAcertoCheque, cast(group_concat(
concat(fp.Descricao, ' - R$ ', replace(cast(pac.valorPagto as char), '.', ','),
if(pac.idContaBanco>0, Concat(' Banco: ', cb.nome, ' Agência: ', cb.agencia, ' Conta: ', cb.conta), '')
) SEPARATOR ', ') as char) as FormasPagto
from pagto_acerto_cheque pac
left join formapagto fp on (pac.idFormaPagto=fp.idformaPagto)
left join conta_banco cb on (pac.idContaBanco=cb.idContaBanco)
group by idAcertoCheque
) as temp on (a.idAcertoCheque=temp.idAcertoCheque)
where 1");
if (idAcertoCheque > 0)
{
sql.Append(" and a.idAcertoCheque=");
sql.Append(idAcertoCheque);
criterio.Append("Núm. Acerto: ");
criterio.Append(idAcertoCheque);
criterio.Append(" ");
}
if (idFunc > 0)
{
sql.Append(" and a.idFunc=");
sql.Append(idFunc);
criterio.Append("Funcionário: ");
criterio.Append(idFunc);
criterio.Append(" - ");
criterio.Append(FuncionarioDAO.Instance.GetNome(session, idFunc));
criterio.Append(" ");
}
if (idCliente > 0)
{
sql.Append(" and a.idCliente=");
sql.Append(idCliente);
criterio.Append("Cliente: ");
criterio.Append(ClienteDAO.Instance.GetNome(session, idCliente));
criterio.Append(" ");
}
else if (!String.IsNullOrEmpty(nomeCliente))
{
string ids = ClienteDAO.Instance.GetIds(session, null, nomeCliente, null, 0, null, null, null, null, 0);
sql.Append(" And cli.id_Cli in (");
sql.Append(ids);
sql.Append(")");
criterio.Append("Cliente: ");
criterio.Append(nomeCliente);
criterio.Append(" ");
}
if (!String.IsNullOrEmpty(dataIni))
{
sql.Append(" and a.DataAcerto>=?dataIni");
criterio.Append("Data inicial: ");
criterio.Append(dataIni);
criterio.Append(" ");
}
if (!String.IsNullOrEmpty(dataFim))
{
sql.Append(" and a.DataAcerto<=?dataFim");
criterio.Append("Data término: ");
criterio.Append(dataFim);
criterio.Append(" ");
}
if (chequesCaixaDiario)
{
sql.Append(" and a.idAcertoCheque in (select iac.idAcertoCheque from item_acerto_cheque iac inner join cheques c on " +
"(iac.idCheque=c.idCheque) where c.movcaixadiario)");
criterio.Append("Movimenta caixa diario: ");
criterio.Append(chequesCaixaDiario);
criterio.Append(" ");
}
if (chequesProprios != null)
{
sql.Append(" and a.idAcertoCheque in (select iac.idAcertoCheque from item_acerto_cheque iac inner join cheques c on " +
"(iac.idCheque=c.idCheque) where c.tipo=");
sql.Append(chequesProprios.Value ? "1" : "2");
sql.Append(")");
criterio.Append("Cheques ");
criterio.Append(chequesProprios.Value ? "Próprios" : "de Terceiros");
criterio.Append(" ");
}
return(sql.ToString().Replace("$$$", criterio.ToString()));
}
/// <summary>
/// Atualiza os dados contidos no objUpdate no BD.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="model">Model contendo os dados a serem atualizados.</param>
/// <param name="propertiesNamesUpdate">Nome das propriedades separadas por virgula, que ser�o atualizadas no comando.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="GDAConditionalClauseException">Parameters do not exist to build the conditional clause.</exception>
/// <exception cref="GDAException"></exception>
/// <returns>N�mero de linhas afetadas.</returns>
public static int Update(GDASession session, object model, string propertiesNamesUpdate)
{
return(GetDAO(model).Update(session, model, propertiesNamesUpdate));
}