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
{
var produto = new ConverterCadastroAtualizacaoParaProdutoPedido(dadosParaCadastro)
.ConverterParaProdutoPedido();
produto.IdPedido = (uint)idPedido;
var idProduto = ProdutosPedidoDAO.Instance.Insert(sessao, produto);
sessao.Commit();
return(this.Criado(string.Format("Produto cadastrado com sucesso no pedido {0}!", idPedido), idProduto));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao(string.Format("Erro ao inserir o produto no pedido {0}.", idPedido), e));
}
}
}
public IHttpActionResult ExcluirProcesso(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdProcesso(sessao, id);
if (validacao != null)
{
return(validacao);
}
sessao.BeginTransaction();
EtiquetaProcessoDAO.Instance.DeleteByPrimaryKey(sessao, id);
sessao.Commit();
return(this.Aceito($"Processo de etiqueta {id} excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir processo {id}.", ex));
}
}
}
public override uint Insert(DepositoNaoIdentificado objInsert)
{
FilaOperacoes.InserirDepositoNaoIdentificado.AguardarVez();
using (var transaction = new GDATransaction(System.Data.IsolationLevel.ReadCommitted))
{
try
{
transaction.BeginTransaction();
var retorno = Insert(transaction, objInsert);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
ErroDAO.Instance.InserirFromException("Insert - DepositoNaoIdentificadoDAO", ex);
throw;
}
finally
{
FilaOperacoes.InserirDepositoNaoIdentificado.ProximoFila();
}
}
}
public IHttpActionResult AtualizarMedidaProjeto(int id, [FromBody] CadastroAtualizacaoDto dadosParaAlteracao)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdMedidaProjeto(sessao, id);
if (validacao != null)
{
return(validacao);
}
var medidaProjetoAtual = MedidaProjetoDAO.Instance.GetElementByPrimaryKey(sessao, id);
medidaProjetoAtual = new ConverterCadastroAtualizacaoParaMedidaProjeto(dadosParaAlteracao, medidaProjetoAtual)
.ConverterParaMedidaProjeto();
MedidaProjetoDAO.Instance.Update(sessao, medidaProjetoAtual);
sessao.Commit();
return(this.Aceito($"Medida de projeto atualizada com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar medida de projeto.", ex));
}
}
}
public IHttpActionResult CadastrarRegraNaturezaOperacao([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var regra = new ConverterCadastroAtualizacaoParaRegraNaturezaOperacao(dadosParaCadastro)
.ConverterParaRegraNaturezaOperacao();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Fiscal.Negocios.ICfopFluxo>()
.SalvarRegraNaturezaOperacao(regra);
if (!resultado)
{
sessao.Rollback();
return(this.ErroValidacao($"Falha ao cadastrar regra de natureza de operação. {resultado.Message.Format()}"));
}
sessao.Commit();
return(this.Criado("Regra de natureza de operação cadastrada com sucesso!", 0));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar regra de natureza de operação.", ex));
}
}
}
public IHttpActionResult ReabrirPedido(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdPedido(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
PedidoDAO.Instance.Reabrir(sessao, (uint)id);
sessao.Commit();
return(this.Aceito($"Pedido {id} reaberto."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao(ex.Message, ex));
}
}
}
public IHttpActionResult InserirOuAtualizarLimiteCheque(int id, [FromBody] CadastroAtualizacaoDto dados)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var limiteCheque = LimiteChequeCpfCnpjDAO.Instance.GetElementByPrimaryKey(sessao, id);
limiteCheque = new ConverterCadastroAtualizacaoParaLimiteChequeCpfCnpj(dados, limiteCheque)
.ConverterParaLimiteCheque();
LimiteChequeCpfCnpjDAO.Instance.InsertOrUpdate(sessao, limiteCheque);
sessao.Commit();
return(this.Aceito("Limite de cheque atualizado com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Erro ao atualizar limite de cheque.", ex));
}
}
}
public override int Update(ImpostoServ objUpdate)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
var ImpServAtual = GetElement(transaction, objUpdate.IdImpostoServ);
var retorno = Update(transaction, objUpdate);
//// Cria o Log ao atualizar o imposto/Serv
LogAlteracaoDAO.Instance.LogImpostoServico(transaction, ImpServAtual, objUpdate);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
public IHttpActionResult ExcluirAssociacaoProprietarioVeiculo(string placa, int idProprietario)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExclusaoAssociacaoProprietarioVeiculo(sessao, idProprietario, placa);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var associacaoProprietarioComVeiculo = Data.DAL.CTe.ProprietarioVeiculo_VeiculoDAO.Instance.GetElement(sessao, placa, (uint)idProprietario);
Data.DAL.CTe.ProprietarioVeiculo_VeiculoDAO.Instance.Delete(sessao, associacaoProprietarioComVeiculo);
sessao.Commit();
sessao.Close();
return(this.Aceito(string.Format($"Associação do Proprietário de veículo '{idProprietario}' com o veículo de placa '{placa}' excluída com sucesso!")));
}
catch (Exception e)
{
sessao.Rollback();
sessao.Close();
return(this.ErroValidacao("Erro ao excluir a associação de proprietário com veículo.", e));
}
}
}
//Apagar isso após feito o processo
#region Método para ExecScript
/// <summary>
/// Cria movimentações bancárias para os CNIs que ficaram incorretos anteriormente.
/// </summary>
public string AjustarCNI()
{
var retorno = string.Empty;
var cnis = _fluxoCNI.ObterCartoesNaoIdentificadosDebitoSemMovimentacao();
foreach (var cni in cnis)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
InserirParcelas(transaction, cni);
transaction.Commit();
transaction.Close();
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
retorno += "As movimentações bancárias do CNI " + cni.IdCartaoNaoIdentificado + " não puderam ser criadas. " + ex.InnerException.ToString();
}
}
}
return(retorno);
}
public IHttpActionResult Excluir(int idPedido, int id)
{
using (var sessao = new GDATransaction())
{
Data.Model.ProdutosPedido produto;
var validacao = this.ValidarOperacaoId(sessao, idPedido, id, out produto);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
ProdutosPedidoDAO.Instance.Delete(sessao, produto, false, true);
sessao.Commit();
return(this.Aceito(string.Format("Produto {0} excluído com sucesso do pedido {1}!", id, idPedido)));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao(string.Format("Erro ao excluir o produto {0} do pedido {1}.", id, idPedido), e));
}
}
}
/// <summary>
/// Salvar alterações no Cartão não identificado
/// </summary>
public Colosoft.Business.SaveResult AlterarCartaoNaoIdentificado(Negocios.Entidades.CartaoNaoIdentificado cni)
{
if (cni.ChangedProperties.Contains("Valor") || cni.ChangedProperties.Contains("DataRecebimento"))
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
var parcelas = _fluxoCNI.PesquisarIdsParcelasCNI(cni.IdCartaoNaoIdentificado);
foreach (var item in parcelas)
{
ContasReceberDAO.Instance.DeleteByPrimaryKey(transaction, item);
}
InserirParcelas(transaction, cni);
transaction.Commit();
transaction.Close();
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
ErroDAO.Instance.InserirFromException("Falha ao alterar cartão não identificado.", ex);
return(new Colosoft.Business.SaveResult(false, ("Falha ao receber valor cartão não identificado" + ex.Message.ToString()).GetFormatter()));
}
}
}
return(_fluxoCNI.SalvarCartaoNaoIdentificado(cni));
}
/// <summary>
/// Insere um novo cartão não identificado
/// </summary>
public Colosoft.Business.SaveResult InserirCartaoNaoIdentificado(Negocios.Entidades.CartaoNaoIdentificado cni)
{
var resultado = _fluxoCNI.SalvarCartaoNaoIdentificado(cni);
if (!resultado)
{
return(resultado);
}
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
InserirParcelas(transaction, cni);
transaction.Commit();
transaction.Close();
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
_fluxoCNI.ApagarCartaoNaoIdentificado(cni);
ErroDAO.Instance.InserirFromException("Falha ao inserir cartão não identificado.", ex);
throw new Exception(MensagemAlerta.FormatErrorMsg("Falha ao receber valor cartão não identificado", ex));
}
}
return(new Colosoft.Business.SaveResult(true, null));
}
public override int Update(OperadoraCartao objUpdate)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
var oldObject = GetElementByPrimaryKey(transaction, objUpdate.IdOperadoraCartao);
var possuiCartoesAssociadosAtivos = objPersistence.ExecuteSqlQueryCount(string.Format(@"
SELECT COUNT(IDTIPOCARTAO) FROM tipo_cartao_credito WHERE OPERADORA={0} AND SITUACAO={1}", objUpdate.IdOperadoraCartao, (int)Situacao.Ativo)) > 0;
if (objUpdate.Situacao != oldObject.Situacao && objUpdate.Situacao == Situacao.Inativo && possuiCartoesAssociadosAtivos)
{
throw new Exception("A operadora de cartão não pode ser alterada pois está em uso em cartões ativos.");
}
var retorno = base.Update(transaction, objUpdate);
LogAlteracaoDAO.Instance.LogOperadoraCartao(transaction, oldObject, objUpdate);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Close();
ErroDAO.Instance.InserirFromException("Alterar Tipo Cartão", ex);
throw ex;
}
}
}
public IHttpActionResult EnviarValidacaoFinanceiro(int id, [FromBody] DadosEntradaDto dadosEntrada)
{
dadosEntrada = dadosEntrada ?? new DadosEntradaDto();
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdPedido(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
PedidoDAO.Instance.DisponibilizaFinalizacaoFinanceiro(sessao, (uint)id, dadosEntrada.Mensagem);
sessao.Commit();
return(this.Aceito($"Pedido {id} enviado para validação pelo financeiro."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao(ex.Message, ex));
}
}
}
public void Iniciar(uint idInventarioEstoque)
{
lock (_iniciarLock)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
if (ObtemValorCampo <InventarioEstoque.SituacaoEnum>(transaction, "Situacao", "IdInventarioEstoque=" + idInventarioEstoque) == InventarioEstoque.SituacaoEnum.EmContagem)
{
throw new Exception("Este inventário já está em contagem.");
}
AlterarSituacao(transaction, idInventarioEstoque, InventarioEstoque.SituacaoEnum.EmContagem);
InserirProdutos(transaction, idInventarioEstoque);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
public IHttpActionResult CriarProducaoRevenda(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdPedido(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var idPedidoProducao = PedidoDAO.Instance.CriarPedidoProducaoPedidoRevenda(sessao, PedidoDAO.Instance.GetElementByPrimaryKey(id));
sessao.Commit();
return(this.Criado($"Pedido de produção {idPedidoProducao} criado.", idPedidoProducao));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao(ex.Message, ex));
}
}
}
public void Finalizar(uint idInventarioEstoque)
{
lock (_finalizarLock)
{
using (var transaction = new GDATransaction())
{
try
{
transaction.BeginTransaction();
if (ObtemValorCampo <InventarioEstoque.SituacaoEnum>(transaction, "Situacao", "IdInventarioEstoque=" + idInventarioEstoque) == InventarioEstoque.SituacaoEnum.Finalizado)
{
throw new Exception("Este inventário já foi finalizado.");
}
AlterarSituacao(transaction, idInventarioEstoque, InventarioEstoque.SituacaoEnum.Finalizado);
objPersistence.ExecuteCommand(transaction, "update inventario_estoque set idFuncFin=" +
UserInfo.GetUserInfo.CodUser + ", dataFin=?data where idInventarioEstoque=" + idInventarioEstoque,
new GDAParameter("?data", DateTime.Now));
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
}
}
}
public IHttpActionResult CadastrarPedido([FromBody] Models.Pedidos.V1.CadastroAtualizacao.CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarCadastroPedido(sessao, dadosParaCadastro);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
var pedido = new ConverterCadastroAtualizacaoParaPedido(dadosParaCadastro)
.ConverterParaPedido();
var idPedido = PedidoDAO.Instance.Insert(sessao, pedido);
sessao.Commit();
return(this.Criado(string.Format("Pedido {0} inserido com sucesso!", idPedido), idPedido));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao("Erro ao inserir o pedido.", e));
}
}
}
public IHttpActionResult ExcluirProprietarioDeVeiculo(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdProprietarioVeiculo(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
ProprietarioVeiculoDAO.Instance.DeleteByPrimaryKey(sessao, id);
sessao.Commit();
sessao.Close();
return(this.Aceito(string.Format("Proprietário de veículo {0} excluído com sucesso!", id)));
}
catch (Exception e)
{
sessao.Rollback();
sessao.Close();
return(this.ErroValidacao("Erro ao excluir o proprietário de veículo.", e));
}
}
}
public IHttpActionResult AlterarCorAluminio(int id, [FromBody] CadastroAtualizacaoDto dadosParaAlteracao)
{
using (var sessao = new GDATransaction())
{
try
{
var corAluminio = CorAluminioDAO.Instance.GetElementByPrimaryKey(sessao, id);
if (corAluminio == null)
{
return(this.NaoEncontrado($"Cor de alumínio {id} não encontrada."));
}
corAluminio = new ConverterCadastroAtualizacaoParaCorAluminio(dadosParaAlteracao, corAluminio)
.ConverterParaCorAluminio();
sessao.BeginTransaction();
CorAluminioDAO.Instance.Update(sessao, corAluminio);
sessao.Commit();
return(this.Aceito($"Cor de alumínio atualizada com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao atualizar cor de alumínio.", ex));
}
}
}
public IHttpActionResult CancelarDevolucao(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdCheque(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
DepositoChequeDAO.Instance.CancelarDevolucao(sessao, (uint)id);
sessao.Commit();
return(this.Aceito("Devolução de cheque cancelada."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao cancelar devolução.", ex));
}
}
}
public IHttpActionResult Excluir(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdPedidoConferencia(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
PedidoEspelhoDAO.Instance.CancelarEspelho(sessao, (uint)id);
sessao.Commit();
return(this.Ok());
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao("Erro ao cancelar a conferência.", e));
}
}
}
public IHttpActionResult CancelarProtesto(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdCheque(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
Data.Model.Cheques cheque = ChequesDAO.Instance.GetElement(sessao, (uint)id);
cheque.Situacao = (int)Data.Model.Cheques.SituacaoCheque.Devolvido;
ChequesDAO.Instance.UpdateBase(sessao, cheque, false);
sessao.Commit();
return(this.Aceito("Protesto de cheque cancelado."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao("Falha ao cancelar protesto.", ex));
}
}
}
public IHttpActionResult ReenviarEmail(int id)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarExistenciaIdLiberacao(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
Email.EnviaEmailLiberacao(sessao, (uint)id);
LogAlteracaoDAO.Instance.LogReenvioEmailLiberacao(sessao, (uint)id);
sessao.Commit();
return(this.Aceito("O e-mail foi adicionado na fila para ser enviado."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao(ex.Message, ex));
}
}
}
public IHttpActionResult CadastrarAplicacao([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarCadastroAplicacao(sessao, dadosParaCadastro);
if (validacao != null)
{
return(validacao);
}
var aplicacao = new ConverterCadastroAtualizacaoParaAplicacao(dadosParaCadastro)
.ConverterParaAplicacao();
sessao.BeginTransaction();
var idAplicacao = EtiquetaAplicacaoDAO.Instance.Insert(sessao, aplicacao);
sessao.Commit();
return(this.Criado($"Aplicação de etiqueta {idAplicacao} inserida com sucesso!", idAplicacao));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao inserir aplicação.", ex));
}
}
}
/// <summary>
/// (APAGAR: quando alterar para utilizar transação)
/// Cancela um déposito não identificado
/// </summary>
public void Cancelar(uint idDepositoNaoIdentificado, string motivo)
{
FilaOperacoes.CancelarDepositoNaoIdentificado.AguardarVez();
using (var transaction = new GDATransaction(System.Data.IsolationLevel.ReadCommitted))
{
try
{
transaction.BeginTransaction();
Cancelar(transaction, idDepositoNaoIdentificado, motivo);
transaction.Commit();
transaction.Close();
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
finally
{
FilaOperacoes.CancelarDepositoNaoIdentificado.ProximoFila();
}
}
}
public IHttpActionResult CancelarPerdaChapaVidro(int id)
{
using (var sessao = new GDATransaction())
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdPerdaChapaVidro(sessao, id);
if (validacao != null)
{
return(validacao);
}
try
{
var perdaChapaVidro = PerdaChapaVidroDAO.Instance.GetElementByPrimaryKey(sessao, id);
PerdaChapaVidroDAO.Instance.Cancelar(sessao, perdaChapaVidro);
sessao.Commit();
sessao.Close();
return(this.Aceito("Perda de chapa de vidro cancelada com sucesso!"));
}
catch (Exception e)
{
sessao.Rollback();
sessao.Close();
return(this.ErroValidacao("Erro ao cancelar a perda de chapa de vidro.", e));
}
}
}
public override int Update(DepositoNaoIdentificado objUpdate)
{
FilaOperacoes.AtualizarDepositoNaoIdentificado.AguardarVez();
using (var transaction = new GDATransaction(System.Data.IsolationLevel.ReadCommitted))
{
try
{
transaction.BeginTransaction();
var retorno = Update(transaction, objUpdate);
transaction.Commit();
transaction.Close();
return(retorno);
}
catch
{
transaction.Rollback();
transaction.Close();
throw;
}
finally
{
FilaOperacoes.AtualizarDepositoNaoIdentificado.ProximoFila();
}
}
}
public IHttpActionResult ExcluirArquivoRemessa(int id)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarExistenciaIdArquivoRemessa(sessao, id);
if (validacao != null)
{
return(validacao);
}
var arquivoRemessa = ArquivoRemessaDAO.Instance.GetElementByPrimaryKey(sessao, id);
ArquivoRemessaDAO.Instance.Delete(sessao, arquivoRemessa);
sessao.Commit();
return(this.Aceito($"Arquivo de remessa excluído."));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao excluir arquivo de remessa.", ex));
}
}
}