/// <summary>
/// Remove o tipo de cartão do sistema, caso ele não esteja em uso.
/// </summary>
public override int Delete(TipoCartaoCredito objDelete)
{
using (var transaction = new GDATransaction())
{
try
{
if (TipoCartaoCreditoEmUso(transaction, (uint)objDelete.IdTipoCartao))
{
throw new Exception("O tipo cartão não pode ser deletado pois ele já está sendo utilizado.");
}
JurosParcelaCartaoDAO.Instance.ApagarPeloTipoCartaoCredito(transaction, (int)objDelete.IdTipoCartao);
var retorno = base.Delete(transaction, objDelete);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
public IHttpActionResult CadastrarPlanoConta([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var planoConta = new ConverterCadastroAtualizacaoParaPlanoConta(dadosParaCadastro)
.ConverterParaPlanoConta();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Financeiro.Negocios.IPlanoContasFluxo>()
.SalvarPlanoContas(planoConta);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar plano de conta. {resultado.Message.Format()}"));
}
return(this.Criado("Plano de conta cadastrado com sucesso!", planoConta.IdConta));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar plano de conta.", ex));
}
}
}
public IHttpActionResult ExcluirMovimentacao(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdMovimentacaoEstoqueReal(sessao, id);
if (validacao != null)
{
return(validacao);
}
var movimentacao = MovEstoqueDAO.Instance.GetElementByPrimaryKey(id);
MovEstoqueDAO.Instance.Delete(movimentacao);
return(this.Aceito($"Movimentação excluída."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir a movimentação.", ex));
}
}
}
public IHttpActionResult AlterarPosicaoSetor(int id, PosicaoDto posicao)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdSetor(sessao, id);
if (validacao != null)
{
return(validacao);
}
var fluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <PCP.Negocios.ISetorFluxo>();
var resultado = fluxo.AlterarPosicao(id, posicao.Acima);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao alterar a posição do setor. {resultado.Message}"));
}
return(this.Aceito($"Posição do setor alterada com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar setor.", ex));
}
}
}
public IHttpActionResult ExcluirTabelasDescontoAcrescimoCliente(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdTabelaDescontoAcrescimoCliente(sessao, id);
if (validacao != null)
{
return(validacao);
}
var fluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.IClienteFluxo>();
var tabela = fluxo.ObtemTabelaDescontoAcrescimoCliente(id);
var resultado = fluxo.ApagarTabelaDescontoAcrescimo(tabela);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao excluir tabela de desconto/acréscimo de cliente. {resultado.Message.Format()}"));
}
return(this.Aceito($"Tabela de desconto/acréscimo de cliente excluída."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir tabela de desconto/acréscimo.", ex));
}
}
}
public IHttpActionResult ConsultarSituacao(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdNotaFiscal(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var mensagem = Data.NFeUtils.ConsultaSituacao.ConsultaSitNFe((uint)id);
sessao.Commit();
return(this.Aceito(mensagem));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao consultar situação da nota fiscal", ex));
}
}
}
public IHttpActionResult ExcluirOrdemCarga(int id)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdOrdemCarga(sessao, id);
if (validacao != null)
{
return(validacao);
}
var ordemCarga = OrdemCargaDAO.Instance.GetElementByPrimaryKey(sessao, id);
WebGlass.Business.OrdemCarga.Fluxo.OrdemCargaFluxo.Instance.Delete(sessao, ordemCarga);
sessao.Commit();
sessao.Close();
return(this.Aceito($"Ordem de carga excluída."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir ordem de carga.", ex));
}
}
}
public IHttpActionResult ExcluirFabricanteFerragem(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdFabricanteFerragem(sessao, id);
if (validacao != null)
{
return(validacao);
}
var fluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Projeto.Negocios.IFerragemFluxo>();
var fabricante = fluxo.ObterFabricanteFerragem(id);
var resultado = fluxo.ApagarFabricanteFerragem(fabricante);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao excluir fabricante de ferragem. {resultado.Message.Format()}"));
}
return(this.Aceito($"Fabricante de ferragem excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir fabricante de ferragem.", ex));
}
}
}
/// <summary>
/// Método utilizado para enviar email utilizando configurações de cada loja,
/// colocando o e-mail na fila de envio.
/// </summary>
public static uint EnviaEmailAsyncComTransacao(uint idLoja, string emailDestinatario, string assunto, string mensagem, EmailEnvio emailEnvio, bool emailAdmin,
params AnexoEmail[] anexos)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
uint idEmail = EnviaEmailAsync(transaction, idLoja, emailDestinatario, assunto, mensagem, emailEnvio, emailAdmin, anexos);
transaction.Commit();
transaction.Close();
return(idEmail);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
ErroDAO.Instance.InserirFromException("EnviaEmailAsync", ex);
throw;
}
}
}
public IHttpActionResult ExcluirContabilista(int id)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdContabilista(sessao, id);
if (validacao != null)
{
return(validacao);
}
ContabilistaDAO.Instance.DeleteByPrimaryKey(sessao, id);
sessao.Commit();
return(this.Aceito($"Contabilista excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir contabilista.", ex));
}
}
}
public IHttpActionResult AtualizarGrupoProjeto(int id, [FromBody] CadastroAtualizacaoDto dadosParaAlteracao)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdGrupoProjeto(sessao, id);
if (validacao != null)
{
return(validacao);
}
var grupoProjetoAtual = GrupoModeloDAO.Instance.GetElementByPrimaryKey(id);
grupoProjetoAtual = new ConverterCadastroAtualizacaoParaGrupoProjeto(dadosParaAlteracao, grupoProjetoAtual)
.ConverterParaGrupoProjeto();
GrupoModeloDAO.Instance.Update(sessao, grupoProjetoAtual);
sessao.Commit();
return(this.Aceito($"Grupos de projeto atualizado com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar grupo de projeto.", ex));
}
}
}
public IHttpActionResult ExcluirRoteiro(int id)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdRoteiro(sessao, id);
if (validacao != null)
{
return(validacao);
}
var roteiro = RoteiroProducaoDAO.Instance.ObtemElemento(sessao, id);
RoteiroProducaoDAO.Instance.Delete(sessao, roteiro);
RoteiroProducaoSetorDAO.Instance.ApagarPorRoteiroProducao(sessao, roteiro.IdRoteiroProducao);
sessao.Commit();
return(this.Aceito($"Roteiro excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir roteiro.", ex));
}
}
}
public void Reabrir(uint idCte)
{
lock (_reabrirCTeLock)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
var cte = BuscarCte.Instance.GetCte(transaction, idCte);
if (cte.Situacao == (int)Glass.Data.Model.Cte.ConhecimentoTransporte.SituacaoEnum.Aberto)
{
throw new Exception(string.Format("O CTe {0} já foi reaberto.", cte.NumeroCte));
}
ApagarContasPagar(transaction, idCte);
// Altera a situação do CTe
ConhecimentoTransporteDAO.Instance.AlteraSituacao(transaction, idCte, Glass.Data.Model.Cte.ConhecimentoTransporte.SituacaoEnum.Aberto);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
public IHttpActionResult Cadastrar(int idPedido, [FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarIdPedido(sessao, idPedido);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var ambiente = new ConverterCadastroAtualizacaoParaAmbientePedido(dadosParaCadastro)
.ConverterParaAmbientePedido();
ambiente.IdPedido = (uint)idPedido;
var idAmbiente = AmbientePedidoDAO.Instance.Insert(sessao, ambiente);
sessao.Commit();
return(this.Criado(string.Format("Ambiente cadastrado com sucesso no pedido {0}!", idPedido), idAmbiente));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao(string.Format("Erro ao inserir o ambiente no pedido {0}.", idPedido), e));
}
}
}
public IHttpActionResult ReenviarEmail(int id, bool cancelamento)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdNotaFiscal(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
NotaFiscalDAO.Instance.EnviarEmailXml(sessao, NotaFiscalDAO.Instance.GetElement(sessao, (uint)id), cancelamento);
sessao.Commit();
return(this.Aceito("E-mail adicionado à fila de envio."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao reenviar e-mail", ex));
}
}
}
public IHttpActionResult AlterarTipo(int id, [FromBody] CadastroAtualizacaoDto dadosParaAlteracao)
{
using (var sessao = new GDATransaction())
{
try
{
var tipo = TipoClienteDAO.Instance.GetElementByPrimaryKey(sessao, id);
if (tipo == null)
{
return(this.NaoEncontrado($"Tipo de cliente {id} não encontrado."));
}
tipo = new ConverterCadastroAtualizacaoParaTipo(dadosParaAlteracao, tipo)
.ConverterParaTipo();
sessao.BeginTransaction();
TipoClienteDAO.Instance.Update(sessao, tipo);
sessao.Commit();
return(this.Aceito($"Tipo de cliente atualizado com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar tipo de cliente.", ex));
}
}
}
public IHttpActionResult EmitirNfceOffline(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdNotaFiscal(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var retornoEmissao = NotaFiscalDAO.Instance.EmitirNfcOffline((uint)id);
sessao.Commit();
return(this.Aceito(retornoEmissao));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao emitir NFC-e.", ex));
}
}
}
public IHttpActionResult ExcluirCarregamento(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdCarregamento(sessao, id);
if (validacao != null)
{
return(validacao);
}
var carregamento = CarregamentoDAO.Instance.GetElementByPrimaryKey(id);
WebGlass.Business.OrdemCarga.Fluxo.CarregamentoFluxo.Instance.Delete(carregamento);
return(this.Aceito($"Carregamento excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir carregamento.", ex));
}
}
}
public IHttpActionResult AlterarObservacoes(int id, [FromBody] ObservacoesPedidoDto dadosEntrada)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdPedido(sessao, id);
if (validacao != null)
{
return(validacao);
}
sessao.BeginTransaction();
PedidoDAO.Instance.AtualizaObs(sessao, (uint)id, dadosEntrada?.Observacao, dadosEntrada?.ObservacaoLiberacao);
sessao.Commit();
return(this.Aceito($"Pedido {id} atualizado com sucesso!"));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar a observação do pedido {id}.", e));
}
}
}
public IHttpActionResult CadastrarCondutor([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarCadastroCondutor(sessao, dadosParaCadastro);
if (validacao != null)
{
return(validacao);
}
var condutor = new Helper.Condutores.ConverterCadastroAtualizacaoParaCondutor(dadosParaCadastro)
.ConverterParaCondutor();
var idCondutor = CondutoresDAO.Instance.Insert(sessao, condutor);
sessao.Commit();
return(this.Criado($"Condutor {idCondutor} inserido com sucesso!", idCondutor));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao inserir condutor.", ex));
}
}
}
public IHttpActionResult DesassociarPedidoOrdemCarga(int id, int idPedido)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarDesassociacaoPedidoOrdemCarga(sessao, id, idPedido);
if (validacao != null)
{
return(validacao);
}
WebGlass.Business.OrdemCarga.Fluxo.PedidosOCFluxo.Instance.RemoverPedido(sessao, (uint)id, (uint)idPedido);
sessao.Commit();
sessao.Close();
return(this.Aceito($"Pedido {idPedido} desassociado da ordem de carga {id}."));
}
catch (Exception ex)
{
sessao.Rollback();
sessao.Close();
return(this.ErroValidacao($"Erro ao desassociar pedido da ordem de carga.", ex));
}
}
}
public IHttpActionResult AlterarCondutor(int id, [FromBody] CadastroAtualizacaoDto dadosParaAlteracao)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarAtualizacaoCondutor(sessao, id, dadosParaAlteracao);
if (validacao != null)
{
return(validacao);
}
var condutor = CondutoresDAO.Instance.GetElementByPrimaryKey(sessao, id);
if (condutor == null)
{
return(this.NaoEncontrado($"Condutor {id} não encontrado."));
}
condutor = new ConverterCadastroAtualizacaoParaCondutor(dadosParaAlteracao, condutor)
.ConverterParaCondutor();
CondutoresDAO.Instance.Update(sessao, condutor);
sessao.Commit();
return(this.Aceito($"Condutor {id} atualizado com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar condutor.", ex));
}
}
}
public IHttpActionResult ExcluirTurno(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdTurno(sessao, id);
if (validacao != null)
{
return(validacao);
}
var fluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.ITurnoFluxo>();
var turno = fluxo.ObtemTurno(id);
var resultado = fluxo.ApagarTurno(turno);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao excluir turno. {resultado.Message.Format()}"));
}
return(this.Aceito($"Turno excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir turno.", ex));
}
}
}
public IHttpActionResult ExcluirCategoriaConta(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdCategoriaConta(sessao, id);
if (validacao != null)
{
return(validacao);
}
var fluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Financeiro.Negocios.IPlanoContasFluxo>();
var categoriaConta = fluxo.ObtemCategoriaConta(id);
var resultado = fluxo.ApagarCategoriaConta(categoriaConta);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao excluir categoria de conta. {resultado.Message.Format()}"));
}
return(this.Aceito($"Categoria de conta excluída."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir categoria de conta.", ex));
}
}
}
/// <summary>
/// Cancela pagamento
/// </summary>
public void CancelarPagtoComTransacao(uint idPagto, string motivoCanc, bool estornarMovimentacaoBancaria,
DateTime?dataEstornoBanco)
{
lock (_cancelarPagamentoLock)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
CancelarPagto(transaction, idPagto, motivoCanc, estornarMovimentacaoBancaria, dataEstornoBanco);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
public IHttpActionResult Reabrir(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdNotaFiscal(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
NotaFiscalDAO.Instance.ReabrirNotaEntradaTerceiros((uint)id);
sessao.Commit();
return(this.Aceito($"Nota fiscal {id} reaberta."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao reabrir nota fiscal.", ex));
}
}
}
/// <summary>
/// Salva o valor padrão de um banco
/// </summary>
/// <param name="dados"></param>
public void SalvarValorPadrao(DadosCnab dados)
{
using (var trans = new GDATransaction())
{
try
{
trans.BeginTransaction();
var dadosOriginais = ObtemValorPadrao(trans, dados.CodBanco, 0);
dados.IdArquivoRemessa = null;
dados.ValorPadrao = true;
if (dadosOriginais != null)
{
dados.IdDadosCnab = dadosOriginais.IdDadosCnab;
dados.ExistsInStorage = true;
Update(trans, dados);
}
else
{
Insert(trans, dados);
}
trans.Commit();
trans.Close();
}
catch (System.Exception ex)
{
trans.Rollback();
trans.Close();
throw ex;
}
}
}
public IHttpActionResult GerarNotaFiscalComplementar(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdNotaFiscal(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var idNf = NotaFiscalDAO.Instance.GeraNFeComplementar((uint)id);
sessao.Commit();
return(this.Criado("Nota fiscal complementar gerada.", (int)idNf));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao gerar nota complementar.", ex));
}
}
}
public IHttpActionResult CadastrarSubgrupo([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var subgrupo = new ConverterCadastroAtualizacaoParaSubgrupoProduto(dadosParaCadastro)
.ConverterParaSubgrupoProduto();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.IGrupoProdutoFluxo>()
.SalvarSubgrupoProduto(subgrupo);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar subgrupo de produto. {resultado.Message.Format()}"));
}
return(this.Criado("Subgrupo de produto cadastrado com sucesso!", 0));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar subgrupo de produto.", ex));
}
}
}
public override int Update(TipoCartaoCredito objUpdate)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
var antigo = GetElementByPrimaryKey(transaction, objUpdate.IdTipoCartao);
var retorno = Update(transaction, objUpdate);
LogAlteracaoDAO.Instance.LogTipoCartao(transaction, antigo, objUpdate);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
ErroDAO.Instance.InserirFromException("Alterar Tipo Cartão", ex);
throw ex;
}
}
}