public IHttpActionResult CadastrarSetor([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var fabricante = new ConverterCadastroAtualizacaoParaFabricanteFerragem(dadosParaCadastro)
.ConverterParaFabricanteFerragem();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Projeto.Negocios.IFerragemFluxo>()
.SalvarFabricanteFerragem(fabricante);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar fabricante de ferragem. {resultado.Message.Format()}"));
}
return(this.Criado("Fabricante de ferragem cadastrado com sucesso!", fabricante.IdFabricanteFerragem));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar fabricante de ferragem.", ex));
}
}
}
public IHttpActionResult CadastrarTipoFuncionario([FromBody] CadastroAtualizacaoDto dados)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var tipoFuncionario = new ConverterCadastroAtualizacaoParaTipoFuncionario(dados)
.ConverterParaTipoFuncionario();
var id = Microsoft.Practices.ServiceLocation.ServiceLocator.Current
.GetInstance <Glass.Global.Negocios.IFuncionarioFluxo>()
.SalvarTipoFuncionario(tipoFuncionario);
sessao.Commit();
return(this.Criado("Tipo de funcionário cadastrado com sucesso!", id));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar tipo de funcionário.", ex));
}
}
}
public IHttpActionResult CadastrarTurno([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var turno = new ConverterCadastroAtualizacaoParaTurno(dadosParaCadastro)
.ConverterParaTurno();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.ITurnoFluxo>()
.SalvarTurno(turno);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar turno. {resultado.Message.Format()}"));
}
return(this.Criado("Turno cadastrado com sucesso!", turno.IdTurno));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar turno.", 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 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 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 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 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 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 AtualizarContaAPagar(int id, [FromBody] CadastroAtualizacaoDto dados)
{
using (var sessao = new GDATransaction())
{
try
{
sessao.BeginTransaction();
var validacao = this.ValidarExistenciaIdContasPagar(sessao, id);
if (validacao != null)
{
return(validacao);
}
var contaAPagarAtual = Data.DAL.ContasPagarDAO.Instance.GetElementByPrimaryKey(sessao, id);
contaAPagarAtual = new ConverterCadastroAtualizacaoParaContasPagar(dados, contaAPagarAtual)
.ConverterParaContasPagar();
ContasPagarDAO.Instance.Update(sessao, contaAPagarAtual);
sessao.Commit();
sessao.Close();
return(this.Aceito("Conta a pagar atualizada com sucesso!"));
}
catch (Exception ex)
{
sessao.Rollback();
sessao.Close();
return(this.ErroValidacao("Erro ao alterar dados da conta a pagar.", 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 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 Atualizar(int idPedido, int id, [FromBody] CadastroAtualizacaoDto dadosParaAtualizacao)
{
using (var sessao = new GDATransaction())
{
AmbientePedido ambiente;
var validacao = this.ValidarOperacaoId(sessao, idPedido, id, out ambiente);
if (validacao != null)
{
return(validacao);
}
try
{
sessao.BeginTransaction();
ambiente = new ConverterCadastroAtualizacaoParaAmbientePedido(dadosParaAtualizacao, ambiente)
.ConverterParaAmbientePedido();
AmbientePedidoDAO.Instance.Update(sessao, ambiente);
sessao.Commit();
return(this.Aceito(string.Format("Ambiente {0} atualizado com sucesso no pedido {1}!", id, idPedido)));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao(string.Format("Erro ao atualizar o ambiente {0} do pedido {1}.", id, idPedido), e));
}
}
}
public IHttpActionResult CadastrarTabelaDescontoAcrescimoCliente([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var tabela = new ConverterCadastroAtualizacaoParaTabelaDescontoAcrescimoCliente(dadosParaCadastro)
.ConverterParaTabelaDescontoAcrescimoCliente();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.IClienteFluxo>()
.SalvarTabelaDescontoAcrescimo(tabela);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar tabela de desconto/acréscimo de cliente. {resultado.Message.Format()}"));
}
return(this.Criado("Tabela de desconto/acréscimo de cliente inserida com sucesso!", 0));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao inserir tabela de desconto/acréscimo de cliente.", ex));
}
}
}
public IHttpActionResult Atualizar(int idPedido, int id, [FromBody] CadastroAtualizacaoDto dadosParaAtualizacao)
{
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();
produto = new ConverterCadastroAtualizacaoParaProdutoPedido(dadosParaAtualizacao, produto)
.ConverterParaProdutoPedido();
ProdutosPedidoDAO.Instance.UpdateEAtualizaDataEntrega(sessao, produto);
sessao.Commit();
return(this.Aceito(string.Format("Produto {0} atualizado com sucesso no pedido {1}!", id, idPedido)));
}
catch (Exception e)
{
sessao.Rollback();
return(this.ErroValidacao(string.Format("Erro ao atualizar o produto {0} do pedido {1}.", id, idPedido), e));
}
}
}
public IHttpActionResult CadastrarGrupoConta([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var grupoConta = new ConverterCadastroAtualizacaoParaCategoriaConta(dadosParaCadastro)
.ConverterParaCategoriaConta();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Financeiro.Negocios.IPlanoContasFluxo>()
.SalvarCategoriaConta(grupoConta);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar categoria de conta. {resultado.Message.Format()}"));
}
return(this.Criado("Categoria de conta cadastrada com sucesso!", grupoConta.IdCategoriaConta));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar categoria de conta.", ex));
}
}
}
public IHttpActionResult CadastrarSeguradora([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var seguradora = new ConverterCadastroAtualizacaoParaSeguradora(dadosParaCadastro)
.ConverterParaSeguradora();
var resultado = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Fiscal.Negocios.ICTeFluxo>()
.SalvarSeguradora(seguradora);
if (!resultado)
{
return(this.ErroValidacao($"Falha ao cadastrar seguradora. {resultado.Message.Format()}"));
}
return(this.Criado("Seguradora cadastrada com sucesso!", seguradora.IdSeguradora));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar seguradora.", 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));
}
}
}
private IHttpActionResult ValidarCadastroAtualizacaoCondutor(CadastroAtualizacaoDto dados, string tipo)
{
if (dados == null)
{
return(this.ErroValidacao($"É preciso informar os dados para {tipo} do condutor."));
}
return(null);
}
private IHttpActionResult ValidarCadastroAtualizacaoFuncionario(CadastroAtualizacaoDto dados, string tipo)
{
if (dados == null)
{
return(this.ErroValidacao(string.Format("É preciso informar os dados para {0} do funcionário.", tipo)));
}
return(null);
}
private IHttpActionResult ValidarCadastroFuncionario(GDASession sessao, CadastroAtualizacaoDto dados)
{
var erros = new List <Lazy <IHttpActionResult> >();
erros.Add(new Lazy <IHttpActionResult>(() =>
this.ValidarCadastroAtualizacaoFuncionario(dados, "cadastro")));
return(erros.FirstOrDefault(e => e.Value != null)?.Value);
}
private IHttpActionResult ValidarCadastroAtualizacaoProcesso(CadastroAtualizacaoDto dados, string tipo)
{
if (dados == null)
{
return(this.ErroValidacao($"É preciso informar os dados para {tipo} do processo de etiqueta."));
}
return(null);
}
private IHttpActionResult ValidarCadastroAtualizacaoMovimentacaoEstoqueReal(CadastroAtualizacaoDto dados, string tipo)
{
if (dados == null)
{
return(this.ErroValidacao($"É preciso informar os dados para {tipo} da movimentação de estoque."));
}
return(null);
}
public IHttpActionResult AtualizarFuncionario(int id, [FromBody] CadastroAtualizacaoDto dadosParaAtualizacao)
{
using (var sessao = new GDATransaction())
{
var validacao = this.ValidarAtualizacaoFuncionario(sessao, id, dadosParaAtualizacao);
if (validacao != null)
{
return(validacao);
}
var funcionarioFluxo = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.IFuncionarioFluxo>();
var funcionario = funcionarioFluxo.ObtemFuncionario(id);
if (funcionario == null)
{
return(this.NaoEncontrado(string.Format("Funcionário {0} não encontrado.", id)));
}
try
{
funcionario = new ConverterCadastroAtualizacaoParaFuncionario(funcionarioFluxo, dadosParaAtualizacao, funcionario)
.ConverterParaFuncionario();
var resultado = funcionarioFluxo.SalvarFuncionario(funcionario);
if (!resultado)
{
return(this.ErroValidacao($"Erro ao atualizar o funcionário {id}. {resultado.Message.Format()}"));
}
if (!string.IsNullOrWhiteSpace(dadosParaAtualizacao.DocumentosEDadosPessoais?.Foto))
{
byte[] bytes = Convert.FromBase64String(dadosParaAtualizacao.DocumentosEDadosPessoais.Foto);
using (var imagem = new System.IO.MemoryStream(bytes))
{
var repositorio = Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.Entidades.IFuncionarioRepositorioImagens>();
repositorio.SalvarImagem(funcionario.IdFunc, imagem);
}
Microsoft.Practices.ServiceLocation.ServiceLocator
.Current.GetInstance <Global.Negocios.IMenuFluxo>().RemoveMenuFuncMemoria(funcionario.IdFunc);
}
return(this.Aceito(string.Format($"Funcionário {id} atualizado com sucesso!")));
}
catch (Exception e)
{
return(this.ErroValidacao($"Erro ao atualizar o funcionário {id}.", e));
}
}
}
public IHttpActionResult CadastrarMovimentacaoEstoqueFiscal([FromBody] CadastroAtualizacaoDto dadosParaCadastro)
{
using (var sessao = new GDATransaction())
{
try
{
var validacao = this.ValidarCadastroMovimentacaoEstoqueFiscal(sessao, dadosParaCadastro);
if (validacao != null)
{
return(validacao);
}
var movimentacaoEstoqueFiscal = new ConverterCadastroAtualizacaoParaMovimentacaoEstoqueFiscal(dadosParaCadastro)
.ConverterParaMovimentacaoEstoqueFiscal();
sessao.BeginTransaction();
if (dadosParaCadastro.TipoMovimentacao == TipoMovimentacao.TipoMovimentacaoEntrada)
{
MovEstoqueFiscalDAO.Instance.CreditaEstoqueManual(
sessao,
(uint)movimentacaoEstoqueFiscal.IdProd,
(uint)movimentacaoEstoqueFiscal.IdLoja,
movimentacaoEstoqueFiscal.QtdeMov,
movimentacaoEstoqueFiscal.ValorMov,
movimentacaoEstoqueFiscal.DataMov,
movimentacaoEstoqueFiscal.Obs);
}
else if (dadosParaCadastro.TipoMovimentacao == TipoMovimentacao.TipoMovimentacaoSaida)
{
MovEstoqueFiscalDAO.Instance.BaixaEstoqueManual(
sessao,
(uint)movimentacaoEstoqueFiscal.IdProd,
(uint)movimentacaoEstoqueFiscal.IdLoja,
movimentacaoEstoqueFiscal.QtdeMov,
movimentacaoEstoqueFiscal.ValorMov,
movimentacaoEstoqueFiscal.DataMov,
movimentacaoEstoqueFiscal.Obs);
}
else
{
return(this.ErroValidacao($"O tipo de movimentação deve ser informado."));
}
sessao.Commit();
return(this.Criado($"Movimentação de estoque inserida com sucesso!", 0));
}
catch (Exception ex)
{
sessao.Rollback();
return(this.ErroValidacao($"Erro ao cadastrar movimentação de estoque.", ex));
}
}
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ConverterCadastroAtualizacaoParaProdutoPedido"/>.
/// </summary>
/// <param name="cadastro">O DTO de cadastro, enviado para o endpoint.</param>
/// <param name="atual">O produto de pedido atual (opcional), para que sejam aproveitados os valores, se necessário.</param>
public ConverterCadastroAtualizacaoParaProdutoPedido(CadastroAtualizacaoDto cadastro, Data.Model.ProdutosPedido atual = null)
{
this.cadastro = cadastro;
this.produtoPedido = new Lazy <Data.Model.ProdutosPedido>(() =>
{
var destino = atual ?? new Data.Model.ProdutosPedido();
this.ConverterDtoParaModelo(destino);
return(destino);
});
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ConverterCadastroAtualizacaoParaAmbientePedido"/>.
/// </summary>
/// <param name="cadastro">O DTO de cadastro, enviado para o endpoint.</param>
/// <param name="atual">O ambiente de pedido atual (opcional), para que sejam aproveitados os valores, se necessário.</param>
public ConverterCadastroAtualizacaoParaAmbientePedido(CadastroAtualizacaoDto cadastro, AmbientePedido atual = null)
{
this.cadastro = cadastro;
this.ambientePedido = new Lazy <AmbientePedido>(() =>
{
var destino = atual ?? new AmbientePedido();
this.ConverterDtoParaModelo(destino);
return(destino);
});
}
private IHttpActionResult ValidarCadastroPedido(GDASession sessao, CadastroAtualizacaoDto dados)
{
var erros = new List <Lazy <IHttpActionResult> >();
erros.Add(new Lazy <IHttpActionResult>(() =>
this.ValidarCadastroAtualizacaoPedido(dados, "cadastro")));
erros.Add(new Lazy <IHttpActionResult>(() =>
this.ValidarPedidosProntosNaoLiberados(sessao, dados.IdCliente.GetValueOrDefault())));
return(erros.FirstOrDefault(e => e.Value != null)?.Value);
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ConverterCadastroAtualizacaoParaMovimentacaoEstoqueReal"/>.
/// </summary>
/// <param name="cadastro">O DTO de cadastro, enviado para o endpoint.</param>
public ConverterCadastroAtualizacaoParaMovimentacaoEstoqueReal(
CadastroAtualizacaoDto cadastro)
{
this.cadastro = cadastro;
this.movimentacaoEstoque = new Lazy <Data.Model.MovEstoque>(() =>
{
var destino = new Glass.Data.Model.MovEstoque();
this.ConverterDtoParaModelo(destino);
return(destino);
});
}
/// <summary>
/// Inicia uma nova instância da classe <see cref="ConverterCadastroAtualizacaoParaContaBancaria"/>.
/// </summary>
/// <param name="cadastro">O DTO de cadastro, enviado para o endpoint.</param>
/// <param name="atual">A conta bancária atual (opcional), para que sejam aproveitados os valores, se necessário.</param>
public ConverterCadastroAtualizacaoParaContaBancaria(
CadastroAtualizacaoDto cadastro,
ContaBanco atual = null)
{
this.cadastro = cadastro;
this.contaBancaria = new Lazy <ContaBanco>(() =>
{
var destino = atual ?? new ContaBanco();
this.ConverterDtoParaModelo(destino);
return(destino);
});
}
