/// <summary>
/// Retifica uma comissão
/// </summary>
/// <param name="idComissao"></param>
/// <param name="idFunc"></param>
/// <param name="idsContasRemover"></param>
/// <param name="valorComissao"></param>
/// <param name="dataContaPagar"></param>
public void RetificarComissaoContasReceber(uint idComissao, uint idFunc, string idsContasRemover, decimal valorComissao, string dataContaPagar)
{
using (var trans = new GDA.GDATransaction())
{
trans.BeginTransaction();
// Apenas financeiro pagto pode retificar comissões
uint tipoUsuario = UserInfo.GetUserInfo.TipoUsuario;
if (!Config.PossuiPermissao(Config.FuncaoMenuFinanceiroPagto.ControleFinanceiroPagamento))
{
throw new Exception("Você não tem permissão para retificar comissões");
}
var contaPagar = ContasPagarDAO.Instance.GetByComissao(trans, idComissao);
var comissao = GetElementByPrimaryKey(trans, idComissao);
if (comissao == null)
{
throw new Exception("Comissão não encontrada.");
}
if (contaPagar == null || contaPagar.Paga)
{
throw new Exception("Não é possível retificar essa conta, pois ela já foi paga.");
}
try
{
//Remove a associação das contas
ComissaoContasReceberDAO.Instance.DeleteByContasRecebidas(trans, idsContasRemover);
//Verifica a data da conta a pagar
DateTime dataPagar;
if (!DateTime.TryParse(dataContaPagar, out dataPagar))
{
dataPagar = DateTime.Now.AddMonths(1);
}
//Atualiza a conta a pagar
contaPagar.DataVenc = dataPagar;
contaPagar.ValorVenc = valorComissao;
ContasPagarDAO.Instance.Update(trans, contaPagar);
//Atualiza a comissao
comissao.Total = valorComissao;
Update(trans, comissao);
trans.Commit();
trans.Close();
}
catch (Exception ex)
{
trans.Rollback();
trans.Close();
ErroDAO.Instance.InserirFromException("Retificar comissão de contas recebidas", ex);
throw ex;
}
}
}
public override uint Insert(Medicao objInsert)
{
using (var transaction = new GDA.GDATransaction())
{
try
{
transaction.BeginTransaction();
if (objInsert.IdOrcamento > 0 && !OrcamentoDAO.Instance.Exists(transaction, objInsert.IdOrcamento))
{
throw new Exception($"O orçamento {objInsert.IdOrcamento} informado na medição não existe");
}
uint idMedicao = Insert(transaction, objInsert);
transaction.Commit();
transaction.Close();
return(idMedicao);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
throw ex;
}
}
}
/// <summary>
/// Cancela um encontro de contas
/// </summary>
public void CancelaEncontro(uint idEncontroContas, string movito)
{
lock (EncontroContasLock)
{
using (var transaction = new GDA.GDATransaction())
{
try
{
transaction.BeginTransaction();
//Apaga os vinculos das contas a pagar/receber (desmarca a conta como paga ou recebida)
ContasPagarEncontroContasDAO.Instance.RemoveVinculoContaPagar(transaction, idEncontroContas);
ContasReceberEncontroContasDAO.Instance.RemoveVinculoContaReceber(transaction, idEncontroContas);
//Apaga os contas a pagar/receber gerados
var tipoConta = Instance.ObtemTipoContaGerar(transaction, idEncontroContas);
if (tipoConta == 1)
{
ContasPagarDAO.Instance.DeleteByEncontroContas(transaction, idEncontroContas);
}
else if (tipoConta == 2)
{
ContasReceberDAO.Instance.DeleteByEncontroContas(transaction, idEncontroContas);
}
var ec = GetElement(transaction, idEncontroContas);
LogCancelamentoDAO.Instance.LogEncontroContas(transaction, ec, movito, true);
if (ec.Situacao == (int)EncontroContas.SituacaoEncontroContas.Aberto)
{
Delete(transaction, ec);
transaction.Commit();
transaction.Close();
return;
}
ec.Situacao = (int)EncontroContas.SituacaoEncontroContas.Cancelado;
ec.IdFuncCanc = UserInfo.GetUserInfo.IdCliente;
ec.DataCanc = DateTime.Now;
Update(transaction, ec);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
/// <summary>
/// Gera uma medição definitiva para um orçamento.
/// </summary>
/// <param name="idOrca"></param>
public uint GerarMedicaoDefinitivaOrca(uint idOrca)
{
lock (_medicaoDefinitivaLock)
{
using (var transaction = new GDA.GDATransaction())
{
try
{
transaction.BeginTransaction();
Orcamento orca = OrcamentoDAO.Instance.GetElementByPrimaryKey(transaction, idOrca);
if (orca.IdMedicaoDefinitiva.GetValueOrDefault() > 0 &&
objPersistence.ExecuteSqlQueryCount("SELECT IdMedicao FROM medicao WHERE Situacao=" +
(int)Medicao.SituacaoMedicao.Aberta + " AND IdMedicao=" + orca.IdMedicaoDefinitiva.Value) > 0)
{
throw new Exception("Este orçamento já possui uma medição definitiva, cancele-a para gerar outra.");
}
Medicao medicao = new Medicao();
medicao.Bairro = orca.BairroObra != null ? orca.BairroObra : orca.Bairro;
medicao.Cidade = orca.CidadeObra != null ? orca.CidadeObra : orca.Cidade;
medicao.Endereco = orca.EnderecoObra != null ? orca.EnderecoObra : orca.Endereco;
medicao.IdFunc = orca.IdFuncionario;
medicao.NomeCliente = orca.NomeCliente;
medicao.TelCliente = orca.TelCliente;
medicao.EmailCliente = orca.Email;
medicao.Situacao = (int)Medicao.SituacaoMedicao.Aberta;
medicao.Turno = 1;
medicao.IdLoja = orca.IdLoja.GetValueOrDefault(LojaDAO.Instance.ObtemValorCampo <uint>(transaction, "idLoja", null));
medicao.MedicaoDefinitiva = true;
/* Chamado 51781. */
medicao.IdOrcamento = idOrca;
uint idMedicao = Insert(transaction, medicao);
//objPersistence.ExecuteCommand(transaction, "update orcamento set idMedicaoDefinitiva=" + idMedicao +
// " where idOrcamento=" + idOrca);
transaction.Commit();
transaction.Close();
return(idMedicao);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
throw ex;
}
}
}
}
/// <summary>
/// Finaliza o encontro de contas
/// </summary>
public void FinalizaEncontro(uint idEncontroContas, DateTime dataVenc, ref int contaGerada, ref decimal valorGerado)
{
lock (EncontroContasLock)
{
using (var sessao = new GDA.GDATransaction())
{
try
{
sessao.BeginTransaction();
var idsContasPagarPagas = ContasPagarEncontroContasDAO.Instance.ValidaContasPagar(sessao, idEncontroContas);
if (!string.IsNullOrEmpty(idsContasPagarPagas))
{
throw new Exception(string.Format("As contas a pagar: {0} já foram pagas.", idsContasPagarPagas));
}
var idsContasReceberRecebidas = ContasReceberEncontroContasDAO.Instance.ValidaContasReceber(sessao, idEncontroContas);
if (!string.IsNullOrEmpty(idsContasReceberRecebidas))
{
throw new Exception(string.Format("As contas a receber: {0} já foram recebidas.", idsContasReceberRecebidas));
}
//Vincula contas a pagar/receber (Marca a conta como paga ou recebida)
ContasPagarEncontroContasDAO.Instance.GeraVinculoContaPagar(sessao, idEncontroContas);
ContasReceberEncontroContasDAO.Instance.GeraVinculoContaReceber(sessao, idEncontroContas);
Instance.GeraContasPagarReceber(sessao, idEncontroContas, dataVenc,
ref contaGerada, ref valorGerado);
string sql = @"UPDATE encontro_contas
SET situacao=" + (int)EncontroContas.SituacaoEncontroContas.Finalizado + @",
dataFin=?dtFin, idFuncFin=" + UserInfo.GetUserInfo.CodUser + @"
WHERE idEncontroContas=" + idEncontroContas;
objPersistence.ExecuteCommand(sessao, sql, new GDAParameter("?dtFin", DateTime.Now));
sessao.Commit();
sessao.Close();
}
catch
{
sessao.Rollback();
sessao.Close();
throw;
}
}
}
}
public void RemoveComissaoContasRecebidas(Comissao objDelete)
{
// Verifica a conta a pagar gerada por esta comissão foi paga
if (objPersistence.ExecuteSqlQueryCount("Select Count(*) From contas_pagar Where paga=true And idComissao=" +
objDelete.IdComissao) > 0)
{
throw new Exception("Cancele o pagamento da conta gerada por esta comissão.");
}
using (var trans = new GDA.GDATransaction())
{
try
{
trans.BeginTransaction();
//remove o vinculo das contas recebidas com a comissão
ComissaoContasReceberDAO.Instance.DeleteByComissao(trans, objDelete.IdComissao);
// Apaga a conta a pagar da comissão
ContasPagarDAO.Instance.DeleteByComissao(trans, objDelete.IdComissao, "Cancelamento");
//Apaga a comissão
DeleteByPrimaryKey(objDelete.IdComissao);
trans.Commit();
trans.Close();
}
catch (Exception ex)
{
trans.Rollback();
trans.Close();
ErroDAO.Instance.InserirFromException("Cancelar comissão de contas recebidas", ex);
throw ex;
}
}
}
/// <summary>
/// Gera a comissão das contas recebidas
/// </summary>
/// <param name="idFunc"></param>
/// <param name="idsContasR"></param>
/// <param name="dataContaPg"></param>
/// <param name="dataCadIni"></param>
/// <param name="dataCadFim"></param>
/// <param name="dataRecIni"></param>
/// <param name="dataRecFim"></param>
public void GerarComissaoContasRecebidas(uint idFunc, string idsContasR, string dataContaPg, string dataCadIni, string dataCadFim, string dataRecIni, string dataRecFim)
{
using (var trans = new GDA.GDATransaction())
{
trans.BeginTransaction();
idsContasR = idsContasR.Trim(',');
if (idFunc == 0)
{
throw new Exception("O funcionário não foi informado.");
}
if (String.IsNullOrEmpty(idsContasR))
{
throw new Exception("Nenhuma conta foi informada.");
}
var ids = idsContasR.Trim(',').Split(',').Select(x => x.StrParaUint()).ToList();
if (ids.Count == 0)
{
throw new Exception("Nenhuma conta foi informada.");
}
var contas = ContasReceberDAO.Instance.ObtemContasRecebidasParaComissao(trans, idFunc, idsContasR);
var contasFora = contas.Where(f => !ids.Contains(f.IdContaR)).Select(f => f.IdContaR).ToList();
contasFora.AddRange(ids.Where(f => !contas.Select(x => x.IdContaR).ToList().Contains(f)).Select(f => f).ToList());
if (contasFora.Count > 0)
{
throw new Exception("As contas: " + string.Join(",", contasFora.Select(f => f.ToString()).ToArray()) + " não estão na listagem");
}
var valorComissao = contas.Sum(f => f.ValorComissao);
if (valorComissao <= 0)
{
throw new Exception("Não há valor para gerar comissão.");
}
try
{
// Cria uma nova comissao
Comissao comissao = new Comissao();
comissao.Total = valorComissao;
comissao.DataRefIni = dataCadIni.StrParaDate().GetValueOrDefault();
comissao.DataRefFim = dataCadFim.StrParaDate().GetValueOrDefault();
comissao.DataRecIni = dataRecIni.StrParaDate();
comissao.DataRecFim = dataRecFim.StrParaDate();
comissao.DataCad = DateTime.Now;
comissao.IdFunc = idFunc;
var idComissao = Insert(trans, comissao);
#region Gera a conta a pagar para a comissão
DateTime dataPagar;
if (!DateTime.TryParse(dataContaPg, out dataPagar))
{
dataPagar = DateTime.Now.AddMonths(1);
}
ContasPagar cp = new ContasPagar();
cp.IdComissao = idComissao;
cp.IdConta = FinanceiroConfig.PlanoContaComissao;
cp.DataVenc = dataPagar;
cp.ValorVenc = valorComissao;
cp.IdLoja = UserInfo.GetUserInfo.IdLoja;
cp.NumParc = 1;
cp.NumParcMax = 1;
cp.Usucad = UserInfo.GetUserInfo.CodUser;
ContasPagarDAO.Instance.Insert(trans, cp);
#endregion
#region Vincula as contas marcadas para gerar comissão
foreach (var c in contas)
{
ComissaoContasReceberDAO.Instance.Insert(trans, new ComissaoContasReceber()
{
IdComissao = (int)idComissao,
IdContaR = (int)c.IdContaR,
Valor = c.ValorComissao
});
}
#endregion
trans.Commit();
trans.Close();
}
catch (Exception ex)
{
trans.Rollback();
trans.Close();
ErroDAO.Instance.InserirFromException("Comissão de contas recebidas", ex);
throw ex;
}
}
}
/// <summary>
/// Finaliza a medição passada e gera um orçamento para a mesma, retornando o id deste
/// </summary>
public uint FinalizarMedicao(uint idMedicao)
{
using (var transaction = new GDA.GDATransaction())
{
try
{
transaction.BeginTransaction();
var login = UserInfo.GetUserInfo;
if (!Config.PossuiPermissao(Config.FuncaoMenuMedicao.EfetuarMedicao))
{
throw new Exception("Apenas o Aux. Escritório Medição pode finalizar medições.");
}
var medicao = GetMedicao(transaction, idMedicao);
//variavel utilizada apenas para o log, para não ter que ir no banco novamente buscar a medição.
var medicaoLog = medicao;
if (medicao.Situacao == (int)Medicao.SituacaoMedicao.Finalizada)
{
throw new Exception("Medição já finalizada.");
}
medicao.Situacao = (int)Medicao.SituacaoMedicao.Finalizada;
medicao.IdFuncConf = login.CodUser;
medicao.DataConf = DateTime.Now;
uint idOrca = 0;
/* Chamado 50817. */
// Caso a medição esteja associada a um pedido ou a um orçamento, não gera o orçamento ou
// retorna o ID do orçamento com medição definitiva.
if (medicao.IdPedido.GetValueOrDefault() == 0 && medicao.IdOrcamento.GetValueOrDefault() == 0)
{
Orcamento orca = new Orcamento();
orca.Bairro = medicao.Bairro;
orca.Cidade = medicao.Cidade;
orca.Endereco = medicao.Endereco;
orca.IdFuncionario = medicao.IdFunc == 0 ? null : medicao.IdFunc;
orca.NomeCliente = medicao.NomeCliente;
orca.TelCliente = medicao.TelCliente;
orca.CelCliente = medicao.CelCliente;
orca.Email = medicao.EmailCliente;
orca.TipoEntrega = (int?)Orcamento.TipoEntregaOrcamento.Temperado;
orca.Validade = OrcamentoConfig.DadosOrcamento.ValidadeOrcamento;
orca.PrazoEntrega = OrcamentoConfig.DadosOrcamento.PrazoEntregaOrcamento;
orca.FormaPagto = !string.IsNullOrEmpty(medicao.FormaPagto) ? medicao.FormaPagto :
OrcamentoConfig.DadosOrcamento.FormaPagtoOrcamento;
orca.Situacao = (int)Orcamento.SituacaoOrcamento.EmAberto;
idOrca = OrcamentoDAO.Instance.Insert(transaction, orca);
medicao.IdOrcamento = idOrca;
}
LogAlteracaoDAO.Instance.LogMedicao(GetMedicao(idMedicao), medicao);
Update(transaction, medicao);
transaction.Commit();
transaction.Close();
return(idOrca);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
throw ex;
}
}
}
/// <summary>
/// Retifica um encontro de contas
/// </summary>
public void RetificaEncontro(int idEncontroContas, List <string> idsContasPagar, List <string> idsContasReceber,
DateTime dataVenc, ref int contaGerada, ref decimal valorGerado)
{
lock (EncontroContasLock)
{
using (var transaction = new GDA.GDATransaction())
{
try
{
transaction.BeginTransaction();
//Apaga as contas a pagar/receber geradas
var tipoConta = Instance.ObtemTipoContaGerar(transaction, (uint)idEncontroContas);
if (tipoConta == 1)
{
ContasPagarDAO.Instance.DeleteByEncontroContas(transaction, (uint)idEncontroContas);
}
else if (tipoConta == 2)
{
ContasReceberDAO.Instance.DeleteByEncontroContas(transaction, (uint)idEncontroContas);
}
//Apaga os vinculos das contas a pagar/receber (desmarca a conta como paga ou recebida)
ContasPagarEncontroContasDAO.Instance.RemoveVinculoContaPagar(transaction, (uint)idEncontroContas);
ContasReceberEncontroContasDAO.Instance.RemoveVinculoContaReceber(transaction, (uint)idEncontroContas);
foreach (var idContaPg in idsContasPagar)
{
ContasPagarEncontroContasDAO.Instance.DeleteByIdContaPg(transaction, idContaPg.StrParaUint());
}
foreach (var idContaR in idsContasReceber)
{
ContasReceberEncontroContasDAO.Instance.DeleteByIdContaR(transaction, idContaR.StrParaUint());
}
//Vincula contas a pagar/receber (Marca a conta como paga ou recebida)
ContasPagarEncontroContasDAO.Instance.GeraVinculoContaPagar(transaction, (uint)idEncontroContas);
ContasReceberEncontroContasDAO.Instance.GeraVinculoContaReceber(transaction, (uint)idEncontroContas);
//Gera contas a pagar/receber
Instance.GeraContasPagarReceber(transaction, (uint)idEncontroContas, dataVenc, ref contaGerada, ref valorGerado);
//Salva log de retificação
var dados =
string.Format(
"Contas a pagar removidas: {0} Contas a receber removidas: {1}",
string.Join(",", idsContasPagar), string.Join(",", idsContasReceber));
Instance.AtualizaObs(transaction, (uint)idEncontroContas, dados);
var ec = Instance.GetElement(transaction, (uint)idEncontroContas);
ec.DadosRetificar = dados;
LogAlteracaoDAO.Instance.LogEncontroContas(transaction, ec);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
