From 1f4e14b2e973ee7de337fd4866d9a5ceff5cb6d1 Mon Sep 17 00:00:00 2001 From: Lucas Faria Mendes Date: Mon, 30 Mar 2026 10:38:18 -0300 Subject: chore: location --- .../ViewModels/Financeiro/BancosContasViewModel.cs | 604 +++++++++++++++++++++ 1 file changed, 604 insertions(+) create mode 100644 Codemerx/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs (limited to 'Codemerx/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs') diff --git a/Codemerx/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs b/Codemerx/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs new file mode 100644 index 0000000..e83a4eb --- /dev/null +++ b/Codemerx/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs @@ -0,0 +1,604 @@ +using Gestor.Application.Helpers; +using Gestor.Application.Servicos.Financeiro; +using Gestor.Application.Servicos.Generic; +using Gestor.Application.ViewModels.Generic; +using Gestor.Common.Validation; +using Gestor.Model.Domain.Financeiro; +using Gestor.Model.Domain.Generic; +using Gestor.Model.Domain.Seguros; +using Gestor.Model.Helper; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Threading.Tasks; +using System.Windows.Media; + +namespace Gestor.Application.ViewModels.Financeiro +{ + public class BancosContasViewModel : BaseFinanceiroViewModel + { + private readonly BancosContasServico _bancosContasServico; + + public Gestor.Model.Domain.Financeiro.BancosContas CancelBancosContas; + + private long _ultimoId; + + private Gestor.Model.Domain.Financeiro.BancosContas _selectedBancosContas; + + private SolidColorBrush _corDoSaldo = new SolidColorBrush(Colors.Green); + + private ObservableCollection _bancosContasFiltrados = new ObservableCollection(); + + private bool _isExpanded; + + private ObservableCollection _saldos = new ObservableCollection(); + + private bool _habilitarFecharSaldo; + + private Saldo _selectedSaldo = new Saldo(); + + private string _saldoAtual; + + private decimal? _valorAbertura; + + private DateTime? _dataAbertura; + + private bool _incluindo; + + public List BancosContas + { + get; + set; + } + + public ObservableCollection BancosContasFiltrados + { + get + { + return this._bancosContasFiltrados; + } + set + { + this._bancosContasFiltrados = value; + this.IsExpanded = (value != null ? value.Count > 0 : false); + base.OnPropertyChanged("BancosContasFiltrados"); + } + } + + public SolidColorBrush CorDoSaldo + { + get + { + return this._corDoSaldo; + } + set + { + this._corDoSaldo = value; + base.OnPropertyChanged("CorDoSaldo"); + } + } + + public DateTime? DataAbertura + { + get + { + return this._dataAbertura; + } + set + { + this._dataAbertura = value; + base.OnPropertyChanged("DataAbertura"); + } + } + + public bool HabilitarFecharSaldo + { + get + { + return this._habilitarFecharSaldo; + } + set + { + this._habilitarFecharSaldo = value; + base.OnPropertyChanged("HabilitarFecharSaldo"); + } + } + + public bool Incluindo + { + get + { + return this._incluindo; + } + set + { + this._incluindo = value; + base.OnPropertyChanged("Incluindo"); + } + } + + public bool IsExpanded + { + get + { + return this._isExpanded; + } + set + { + this._isExpanded = value; + base.OnPropertyChanged("IsExpanded"); + } + } + + public string SaldoAtual + { + get + { + return this._saldoAtual; + } + set + { + this._saldoAtual = value; + base.OnPropertyChanged("SaldoAtual"); + } + } + + public ObservableCollection Saldos + { + get + { + return this._saldos; + } + set + { + this._saldos = value; + if (value != null && value.Count > 0) + { + this.SelectedSaldo = value.FirstOrDefault((Saldo x) => !x.get_DataFinal().HasValue); + if (this.SelectedSaldo == null) + { + this.UltimoSladoNaoAberto(); + } + } + base.OnPropertyChanged("Saldos"); + } + } + + public Gestor.Model.Domain.Financeiro.BancosContas SelectedBancosContas + { + get + { + return this._selectedBancosContas; + } + set + { + long? nullable; + this._selectedBancosContas = value; + this.CarregarSaldos(value); + if (value != null) + { + nullable = new long?(value.get_Id()); + } + else + { + nullable = null; + } + base.VerificarEnables(nullable); + this.Incluindo = (value == null ? false : value.get_Id() == (long)0); + base.OnPropertyChanged("SelectedBancosContas"); + } + } + + public Saldo SelectedSaldo + { + get + { + return this._selectedSaldo; + } + set + { + bool id; + this._selectedSaldo = value; + if (value == null || value.get_DataFinal().HasValue) + { + id = false; + } + else + { + Usuario usuario = Recursos.Usuario; + if (usuario != null) + { + id = usuario.get_Id() > (long)0; + } + else + { + id = false; + } + } + this.HabilitarFecharSaldo = id; + base.OnPropertyChanged("SelectedSaldo"); + Saldo selectedSaldo = this.SelectedSaldo; + if (selectedSaldo == null) + { + return; + } + selectedSaldo.Initialize(); + } + } + + public decimal? ValorAbertura + { + get + { + return this._valorAbertura; + } + set + { + this._valorAbertura = value; + base.OnPropertyChanged("ValorAbertura"); + } + } + + public BancosContasViewModel() + { + this._bancosContasServico = new BancosContasServico(); + this.Seleciona(); + } + + public async Task CalcularValor() + { + decimal? valorFinal = await this._bancosContasServico.FecharSaldo(this.SelectedSaldo).get_ValorFinal(); + return valorFinal.GetValueOrDefault(); + } + + public async void CancelarAlteracao() + { + base.Loading(true); + if (this.SelectedBancosContas.get_Id() > (long)0) + { + await this.SelecionaBancosDeContas(); + } + BancosContasViewModel bancosContasViewModel = this; + Gestor.Model.Domain.Financeiro.BancosContas bancosConta = this.BancosContasFiltrados.FirstOrDefault((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == this._ultimoId); + if (bancosConta == null) + { + bancosConta = this.BancosContasFiltrados.FirstOrDefault(); + } + bancosContasViewModel.SelecionaBancosContas(bancosConta); + base.Alterar(false); + base.Loading(false); + } + + public async void CarregarSaldos(Gestor.Model.Domain.Financeiro.BancosContas banco) + { + if (banco != null && banco.get_Id() != 0) + { + List saldos = await this._bancosContasServico.BuscarSaldos(banco.get_Id()); + this.CorDoSaldo = new SolidColorBrush(Colors.Green); + this.SaldoAtual = string.Empty; + BancosContasViewModel observableCollection = this; + List saldos1 = saldos; + observableCollection.Saldos = new ObservableCollection( + from x in saldos1 + orderby x.get_DataInicio() descending + select x); + if (this.Saldos.FirstOrDefault() != null) + { + Saldo saldo = new Saldo(); + saldo.set_Conta(this.Saldos.First().get_Conta()); + saldo.set_ValorInicio(this.Saldos.First().get_ValorInicio()); + saldo.set_DataInicio(this.Saldos.First().get_DataInicio()); + saldo.set_DataFinal(new DateTime?(Funcoes.GetNetworkTime())); + Saldo saldo1 = saldo; + saldo1 = await this._bancosContasServico.FecharSaldo(saldo1); + decimal? valorFinal = saldo1.get_ValorFinal(); + decimal num = new decimal(); + if ((valorFinal.GetValueOrDefault() < num) & valorFinal.HasValue) + { + this.CorDoSaldo = new SolidColorBrush(Colors.Red); + } + valorFinal = saldo1.get_ValorFinal(); + this.SaldoAtual = string.Format("SALDO: {0:c}", Math.Round(valorFinal.GetValueOrDefault(), 2)); + } + } + } + + public async void Excluir() + { + if (this.SelectedBancosContas != null && this.SelectedBancosContas.get_Id() != 0) + { + if (await (new BaseServico()).BancosContasUtilizado(this.SelectedBancosContas.get_Id())) + { + await base.ShowMessage("NÃO PODE SER EXCLUÍDO POIS ESTÁ SENDO UTILIZADO EM UM LANÇAMENTO.", "OK", "", false); + } + else if (await base.ShowMessage(string.Concat("DESEJA REALMENTE EXCLUIR A CONTA ", this.SelectedBancosContas.get_Descricao(), " PERMANENTEMENTE?"), "SIM", "NÃO", false)) + { + base.Loading(true); + if (await this._bancosContasServico.Delete(this.SelectedBancosContas)) + { + await this.SelecionaBancosDeContas(); + base.Loading(false); + base.ToggleSnackBar("CONTA EXCLUÍDA COM SUCESSO", true); + } + else + { + base.Loading(false); + } + } + } + } + + public async void ExcluirSaldo() + { + if (this.SelectedSaldo != null && this.SelectedSaldo.get_Id() != 0) + { + if (this.Saldos.Count <= 1) + { + await base.ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO INICIAL DA CONTA.", "OK", "", false); + } + else if (await base.ShowMessage("DESEJA REALMENTE EXCLUIR O SALDO PERMANENTEMENTE?", "SIM", "NÃO", false)) + { + base.Loading(true); + Saldo saldo = this.Saldos.FirstOrDefault((Saldo x) => { + DateTime? dataFinal = x.get_DataFinal(); + DateTime? dataInicio = this.SelectedSaldo.get_DataInicio(); + if (dataFinal.HasValue != dataInicio.HasValue) + { + return false; + } + if (!dataFinal.HasValue) + { + return true; + } + return dataFinal.GetValueOrDefault() == dataInicio.GetValueOrDefault(); + }); + if (saldo != null) + { + saldo.set_DataFinal(null); + saldo.set_ValorFinal(null); + await this._bancosContasServico.Save(saldo); + if (!this._bancosContasServico.Sucesso) + { + base.Loading(false); + } + else if (await this._bancosContasServico.DeleteSaldo(this.SelectedSaldo)) + { + this.CarregarSaldos(this.SelectedBancosContas); + base.Loading(false); + base.ToggleSnackBar("SALDO EXCLUÍDO COM SUCESSO", true); + base.Loading(false); + } + else + { + base.Loading(false); + } + } + else + { + base.Loading(false); + await base.ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO DA CONTA.", "OK", "", false); + } + } + } + } + + public async Task FecharSaldo() + { + this.SelectedSaldo = await this._bancosContasServico.Save(this.SelectedSaldo); + if (this._bancosContasServico.Sucesso) + { + DateTime? dataFinal = this.SelectedSaldo.get_DataFinal(); + if (dataFinal.HasValue) + { + decimal? valorFinal = this.SelectedSaldo.get_ValorFinal(); + if (valorFinal.HasValue) + { + Saldo saldo = new Saldo(); + saldo.set_Conta(this.SelectedSaldo.get_Conta()); + dataFinal = null; + saldo.set_DataFinal(dataFinal); + dataFinal = this.SelectedSaldo.get_DataFinal(); + saldo.set_DataInicio(new DateTime?(dataFinal.Value)); + valorFinal = null; + saldo.set_ValorFinal(valorFinal); + valorFinal = this.SelectedSaldo.get_ValorFinal(); + saldo.set_ValorInicio(valorFinal.Value); + await this._bancosContasServico.Save(saldo); + if (!this._bancosContasServico.Sucesso) + { + return; + } + } + } + this.CarregarSaldos(this.SelectedBancosContas); + base.ToggleSnackBar("SALDO FECHADO COM SUCESSO", true); + } + } + + internal async Task> Filtrar(string value) + { + List bancosContas = await Task.Run>(() => this.FiltrarBancosContas(value)); + return bancosContas; + } + + public List FiltrarBancosContas(string filter) + { + this.BancosContasFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection(this.BancosContas) : new ObservableCollection( + from x in this.BancosContas + where Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Descricao().Trim()).ToUpper().Contains(Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(filter)) + orderby x.get_Ativo() descending, x.get_Descricao() + select x)); + return this.BancosContasFiltrados.ToList(); + } + + public void Incluir() + { + this._ultimoId = this.SelectedBancosContas.get_Id(); + this.DataAbertura = null; + this.ValorAbertura = new decimal?(new decimal()); + this.SaldoAtual = ""; + Gestor.Model.Domain.Financeiro.BancosContas bancosConta = new Gestor.Model.Domain.Financeiro.BancosContas(); + bancosConta.set_Ativo(true); + this.SelectedBancosContas = bancosConta; + this.Saldos = new ObservableCollection(); + this.SelectedSaldo = null; + base.Alterar(true); + } + + public async Task>> Salvar() + { + List> keyValuePairs; + Gestor.Model.Domain.Financeiro.BancosContas bancosConta; + List> keyValuePairs1 = this.SelectedBancosContas.Validate(); + keyValuePairs1.AddRange(this.Validate()); + if (keyValuePairs1.Count <= 0) + { + bancosConta = await this._bancosContasServico.Save(this.SelectedBancosContas); + if (this._bancosContasServico.Sucesso) + { + if (this.SelectedBancosContas.get_Id() == 0 && this.DataAbertura.HasValue && this.ValorAbertura.HasValue) + { + Saldo saldo = new Saldo(); + saldo.set_Conta(bancosConta); + saldo.set_DataInicio(new DateTime?(this.DataAbertura.Value)); + saldo.set_ValorInicio(this.ValorAbertura.Value); + await this._bancosContasServico.Save(saldo); + if (!this._bancosContasServico.Sucesso) + { + keyValuePairs = null; + bancosConta = null; + return keyValuePairs; + } + } + await this.SelecionaBancosDeContas(); + this.SelecionaBancosContas(bancosConta); + Recursos.BancosContas = this.BancosContas; + base.Alterar(false); + base.ToggleSnackBar("CONTA SALVA COM SUCESSO", true); + keyValuePairs = null; + } + else + { + keyValuePairs = null; + } + } + else + { + keyValuePairs = keyValuePairs1; + } + bancosConta = null; + return keyValuePairs; + } + + private async void Seleciona() + { + base.Loading(true); + await base.PermissaoTela(26); + await this.SelecionaBancosDeContas(); + base.Loading(false); + } + + public void SelecionaBancosContas(Gestor.Model.Domain.Financeiro.BancosContas bancosContas) + { + base.Loading(true); + this.SelectedBancosContas = this.BancosContasFiltrados.FirstOrDefault((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == bancosContas.get_Id()); + base.Loading(false); + } + + private async Task SelecionaBancosDeContas() + { + base.Loading(true); + List bancosContas = await this._bancosContasServico.BuscarBancos(); + BancosContasViewModel list = this; + List bancosContas1 = bancosContas; + IOrderedEnumerable ativo = + from x in bancosContas1 + orderby x.get_Ativo() descending + select x; + list.BancosContas = ativo.ThenBy((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Descricao()).ToList(); + this.BancosContasFiltrados = new ObservableCollection(this.BancosContas); + if (this.BancosContasFiltrados.Count <= 0) + { + this.SelectedBancosContas = new Gestor.Model.Domain.Financeiro.BancosContas(); + this.Saldos = new ObservableCollection(); + this.DataAbertura = null; + this.ValorAbertura = new decimal?(new decimal()); + this.SaldoAtual = ""; + base.Alterar(false); + base.EnableMenu = false; + } + else + { + this.SelecionaBancosContas(this.BancosContasFiltrados.First()); + } + Recursos.BancosContas = bancosContas; + base.Loading(false); + } + + private async void UltimoSladoNaoAberto() + { + Saldo saldo = this.Saldos.ToList().Find((Saldo x) => { + DateTime? dataInicio = x.get_DataInicio(); + DateTime? nullable = this.Saldos.Max((Saldo r) => r.get_DataInicio()); + if (dataInicio.HasValue != nullable.HasValue) + { + return false; + } + if (!dataInicio.HasValue) + { + return true; + } + return dataInicio.GetValueOrDefault() == nullable.GetValueOrDefault(); + }); + DateTime? dataFinal = saldo.get_DataFinal(); + bool hasValue = dataFinal.HasValue; + if (hasValue) + { + hasValue = await base.ShowMessage("O ÚLTIMO SALDO NÃO ESTÁ ABERTO. DESEJA ABRÍ-LO AGORA?", "SIM", "NÃO", false); + } + if (hasValue) + { + dataFinal = null; + saldo.set_DataFinal(dataFinal); + saldo.set_ValorFinal(null); + this.SelectedSaldo = await this._bancosContasServico.Save(saldo); + this.SelectedBancosContas = this.SelectedBancosContas; + } + saldo = null; + } + + public List> Validate() + { + List> keyValuePairs = new List>(); + if (this.BancosContas.Where((Gestor.Model.Domain.Financeiro.BancosContas x) => { + if (x.get_Descricao() != this.SelectedBancosContas.get_Descricao()) + { + return false; + } + return x.get_Id() != this.SelectedBancosContas.get_Id(); + }).Any()) + { + Gestor.Model.Helper.ValidationHelper.AddValue(keyValuePairs, "Descricao|DESCRIÇÃO", "NÃO É POSSÍVEL SALVAR MAIS DE UMA CONTA COM A MESMA DESCRIÇÃO.", true); + } + if (this.SelectedBancosContas.get_Id() == 0) + { + if (!this.DataAbertura.HasValue) + { + Gestor.Model.Helper.ValidationHelper.AddValue(keyValuePairs, "DataAbertura|ABERTURA", "É NECESSÁRIO PREENCHER A DATA DE ABERTURA DA CONTA.", true); + } + else if (DateTime.Compare(this.DataAbertura.Value, new DateTime(1753, 1, 1)) < 0 || DateTime.Compare(this.DataAbertura.Value, new DateTime(9999, 12, 31)) > 0) + { + Gestor.Model.Helper.ValidationHelper.AddValue(keyValuePairs, "DataAbertura|ABERTURA", "DATA INVÁLIDA", true); + } + if (!this.ValorAbertura.HasValue) + { + Gestor.Model.Helper.ValidationHelper.AddValue(keyValuePairs, "ValorAbertura|VALOR", "É NECESSÁRIO PREENCHER O VALOR DE ABERTURA DA CONTA.", true); + } + } + return keyValuePairs; + } + } +} \ No newline at end of file -- cgit v1.2.3