decompiler.com

1 files changed, 542 insertions, 0 deletions

diff --git a/Decompiler/Gestor.Application.ViewModels.Financeiro/BancosContasViewModel.cs b/Decompiler/Gestor.Application.ViewModels.Financeiro/BancosContasViewModel.cs
new file mode 100644
index 0000000..579dbd1
--- /dev/null
+++ b/Decompiler/Gestor.Application.ViewModels.Financeiro/BancosContasViewModel.cs
@@ -0,0 +1,542 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Media;
+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.Common;
+using Gestor.Model.Domain.Financeiro;
+using Gestor.Model.Domain.Generic;
+using Gestor.Model.Domain.Seguros;
+using Gestor.Model.Helper;
+
+namespace Gestor.Application.ViewModels.Financeiro;
+
+public class BancosContasViewModel : BaseFinanceiroViewModel
+{
+	private readonly BancosContasServico _bancosContasServico;
+
+	public BancosContas CancelBancosContas;
+
+	private long _ultimoId;
+
+	private BancosContas _selectedBancosContas;
+
+	private SolidColorBrush _corDoSaldo = new SolidColorBrush(Colors.Green);
+
+	private ObservableCollection<BancosContas> _bancosContasFiltrados = new ObservableCollection<BancosContas>();
+
+	private bool _isExpanded;
+
+	private ObservableCollection<Saldo> _saldos = new ObservableCollection<Saldo>();
+
+	private bool _habilitarFecharSaldo;
+
+	private Saldo _selectedSaldo = new Saldo();
+
+	private string _saldoAtual;
+
+	private decimal? _valorAbertura;
+
+	private DateTime? _dataAbertura;
+
+	private bool _incluindo;
+
+	public List<BancosContas> BancosContas { get; set; }
+
+	public BancosContas SelectedBancosContas
+	{
+		get
+		{
+			return _selectedBancosContas;
+		}
+		set
+		{
+			_selectedBancosContas = value;
+			CarregarSaldos(value);
+			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
+			Incluindo = value != null && ((DomainBase)value).Id == 0;
+			OnPropertyChanged("SelectedBancosContas");
+		}
+	}
+
+	public SolidColorBrush CorDoSaldo
+	{
+		get
+		{
+			return _corDoSaldo;
+		}
+		set
+		{
+			_corDoSaldo = value;
+			OnPropertyChanged("CorDoSaldo");
+		}
+	}
+
+	public ObservableCollection<BancosContas> BancosContasFiltrados
+	{
+		get
+		{
+			return _bancosContasFiltrados;
+		}
+		set
+		{
+			_bancosContasFiltrados = value;
+			IsExpanded = value != null && value.Count > 0;
+			OnPropertyChanged("BancosContasFiltrados");
+		}
+	}
+
+	public bool IsExpanded
+	{
+		get
+		{
+			return _isExpanded;
+		}
+		set
+		{
+			_isExpanded = value;
+			OnPropertyChanged("IsExpanded");
+		}
+	}
+
+	public ObservableCollection<Saldo> Saldos
+	{
+		get
+		{
+			return _saldos;
+		}
+		set
+		{
+			_saldos = value;
+			if (value != null && value.Count > 0)
+			{
+				SelectedSaldo = ((IEnumerable<Saldo>)value).FirstOrDefault((Func<Saldo, bool>)((Saldo x) => !x.DataFinal.HasValue));
+				if (SelectedSaldo == null)
+				{
+					UltimoSladoNaoAberto();
+				}
+			}
+			OnPropertyChanged("Saldos");
+		}
+	}
+
+	public bool HabilitarFecharSaldo
+	{
+		get
+		{
+			return _habilitarFecharSaldo;
+		}
+		set
+		{
+			_habilitarFecharSaldo = value;
+			OnPropertyChanged("HabilitarFecharSaldo");
+		}
+	}
+
+	public Saldo SelectedSaldo
+	{
+		get
+		{
+			return _selectedSaldo;
+		}
+		set
+		{
+			_selectedSaldo = value;
+			int habilitarFecharSaldo;
+			if (value != null && !value.DataFinal.HasValue)
+			{
+				Usuario usuario = Recursos.Usuario;
+				habilitarFecharSaldo = ((usuario != null && ((DomainBase)usuario).Id > 0) ? 1 : 0);
+			}
+			else
+			{
+				habilitarFecharSaldo = 0;
+			}
+			HabilitarFecharSaldo = (byte)habilitarFecharSaldo != 0;
+			OnPropertyChanged("SelectedSaldo");
+			Saldo selectedSaldo = SelectedSaldo;
+			if (selectedSaldo != null)
+			{
+				((DomainBase)selectedSaldo).Initialize();
+			}
+		}
+	}
+
+	public string SaldoAtual
+	{
+		get
+		{
+			return _saldoAtual;
+		}
+		set
+		{
+			_saldoAtual = value;
+			OnPropertyChanged("SaldoAtual");
+		}
+	}
+
+	public decimal? ValorAbertura
+	{
+		get
+		{
+			return _valorAbertura;
+		}
+		set
+		{
+			_valorAbertura = value;
+			OnPropertyChanged("ValorAbertura");
+		}
+	}
+
+	public DateTime? DataAbertura
+	{
+		get
+		{
+			return _dataAbertura;
+		}
+		set
+		{
+			_dataAbertura = value;
+			OnPropertyChanged("DataAbertura");
+		}
+	}
+
+	public bool Incluindo
+	{
+		get
+		{
+			return _incluindo;
+		}
+		set
+		{
+			_incluindo = value;
+			OnPropertyChanged("Incluindo");
+		}
+	}
+
+	public BancosContasViewModel()
+	{
+		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0010: Expected O, but got Unknown
+		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0031: Expected O, but got Unknown
+		_bancosContasServico = new BancosContasServico();
+		Seleciona();
+	}
+
+	public async void CarregarSaldos(BancosContas banco)
+	{
+		if (banco == null || ((DomainBase)banco).Id == 0L)
+		{
+			return;
+		}
+		List<Saldo> source = await _bancosContasServico.BuscarSaldos(((DomainBase)banco).Id);
+		CorDoSaldo = new SolidColorBrush(Colors.Green);
+		SaldoAtual = string.Empty;
+		Saldos = new ObservableCollection<Saldo>(source.OrderByDescending((Saldo x) => x.DataInicio));
+		if (Saldos.FirstOrDefault() != null)
+		{
+			Saldo saldo = new Saldo
+			{
+				Conta = Saldos.First().Conta,
+				ValorInicio = Saldos.First().ValorInicio,
+				DataInicio = Saldos.First().DataInicio,
+				DataFinal = Funcoes.GetNetworkTime()
+			};
+			saldo = await _bancosContasServico.FecharSaldo(saldo);
+			decimal? valorFinal = saldo.ValorFinal;
+			if ((valorFinal.GetValueOrDefault() < default(decimal)) & valorFinal.HasValue)
+			{
+				CorDoSaldo = new SolidColorBrush(Colors.Red);
+			}
+			SaldoAtual = $"SALDO: {Math.Round(saldo.ValorFinal.GetValueOrDefault(), 2):c}";
+		}
+	}
+
+	private async void UltimoSladoNaoAberto()
+	{
+		Saldo ultimoSaldo = Saldos.ToList().Find(delegate(Saldo x)
+		{
+			DateTime? dataInicio = x.DataInicio;
+			DateTime? dateTime = Saldos.Max((Saldo r) => r.DataInicio);
+			if (dataInicio.HasValue != dateTime.HasValue)
+			{
+				return false;
+			}
+			return !dataInicio.HasValue || dataInicio.GetValueOrDefault() == dateTime.GetValueOrDefault();
+		});
+		bool flag = ultimoSaldo.DataFinal.HasValue;
+		if (flag)
+		{
+			flag = await ShowMessage("O ÚLTIMO SALDO NÃO ESTÁ ABERTO. DESEJA ABRÍ-LO AGORA?", "SIM", "NÃO");
+		}
+		if (flag)
+		{
+			ultimoSaldo.DataFinal = null;
+			ultimoSaldo.ValorFinal = null;
+			SelectedSaldo = await _bancosContasServico.Save(ultimoSaldo);
+			SelectedBancosContas = SelectedBancosContas;
+		}
+	}
+
+	private async void Seleciona()
+	{
+		Loading(isLoading: true);
+		await PermissaoTela((TipoTela)26);
+		await SelecionaBancosDeContas();
+		Loading(isLoading: false);
+	}
+
+	private async Task SelecionaBancosDeContas()
+	{
+		Loading(isLoading: true);
+		List<BancosContas> list = await _bancosContasServico.BuscarBancos();
+		BancosContas = (from x in list
+			orderby x.Ativo descending, x.Descricao
+			select x).ToList();
+		BancosContasFiltrados = new ObservableCollection<BancosContas>(BancosContas);
+		if (BancosContasFiltrados.Count > 0)
+		{
+			SelecionaBancosContas(BancosContasFiltrados.First());
+		}
+		else
+		{
+			SelectedBancosContas = new BancosContas();
+			Saldos = new ObservableCollection<Saldo>();
+			DataAbertura = null;
+			ValorAbertura = default(decimal);
+			SaldoAtual = "";
+			Alterar(alterar: false);
+			base.EnableMenu = false;
+		}
+		Recursos.BancosContas = list;
+		Loading(isLoading: false);
+	}
+
+	public void Incluir()
+	{
+		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0051: Expected O, but got Unknown
+		_ultimoId = ((DomainBase)SelectedBancosContas).Id;
+		DataAbertura = null;
+		ValorAbertura = default(decimal);
+		SaldoAtual = "";
+		SelectedBancosContas = new BancosContas
+		{
+			Ativo = true
+		};
+		Saldos = new ObservableCollection<Saldo>();
+		SelectedSaldo = null;
+		Alterar(alterar: true);
+	}
+
+	public async Task<List<KeyValuePair<string, string>>> Salvar()
+	{
+		List<KeyValuePair<string, string>> list = SelectedBancosContas.Validate();
+		list.AddRange(Validate());
+		if (list.Count > 0)
+		{
+			return list;
+		}
+		BancosContas conta = await _bancosContasServico.Save(SelectedBancosContas);
+		if (!_bancosContasServico.Sucesso)
+		{
+			return null;
+		}
+		if (((DomainBase)SelectedBancosContas).Id == 0L && DataAbertura.HasValue && ValorAbertura.HasValue)
+		{
+			Saldo saldo = new Saldo
+			{
+				Conta = conta,
+				DataInicio = DataAbertura.Value,
+				ValorInicio = ValorAbertura.Value
+			};
+			await _bancosContasServico.Save(saldo);
+			if (!_bancosContasServico.Sucesso)
+			{
+				return null;
+			}
+		}
+		await SelecionaBancosDeContas();
+		SelecionaBancosContas(conta);
+		Recursos.BancosContas = BancosContas;
+		Alterar(alterar: false);
+		ToggleSnackBar("CONTA SALVA COM SUCESSO");
+		return null;
+	}
+
+	public List<KeyValuePair<string, string>> Validate()
+	{
+		List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
+		if (BancosContas.Where((BancosContas x) => x.Descricao == SelectedBancosContas.Descricao && ((DomainBase)x).Id != ((DomainBase)SelectedBancosContas).Id).Any())
+		{
+			ValidationHelper.AddValue<string, string>(list, "Descricao|DESCRIÇÃO", "NÃO É POSSÍVEL SALVAR MAIS DE UMA CONTA COM A MESMA DESCRIÇÃO.", true);
+		}
+		if (((DomainBase)SelectedBancosContas).Id == 0L)
+		{
+			if (!DataAbertura.HasValue)
+			{
+				ValidationHelper.AddValue<string, string>(list, "DataAbertura|ABERTURA", "É NECESSÁRIO PREENCHER A DATA DE ABERTURA DA CONTA.", true);
+			}
+			else if (DateTime.Compare(DataAbertura.Value, new DateTime(1753, 1, 1)) < 0 || DateTime.Compare(DataAbertura.Value, new DateTime(9999, 12, 31)) > 0)
+			{
+				ValidationHelper.AddValue<string, string>(list, "DataAbertura|ABERTURA", "DATA INVÁLIDA", true);
+			}
+			if (!ValorAbertura.HasValue)
+			{
+				ValidationHelper.AddValue<string, string>(list, "ValorAbertura|VALOR", "É NECESSÁRIO PREENCHER O VALOR DE ABERTURA DA CONTA.", true);
+			}
+		}
+		return list;
+	}
+
+	public async void CancelarAlteracao()
+	{
+		Loading(isLoading: true);
+		if (((DomainBase)SelectedBancosContas).Id > 0)
+		{
+			await SelecionaBancosDeContas();
+		}
+		SelecionaBancosContas(((IEnumerable<BancosContas>)BancosContasFiltrados).FirstOrDefault((Func<BancosContas, bool>)((BancosContas x) => ((DomainBase)x).Id == _ultimoId)) ?? BancosContasFiltrados.FirstOrDefault());
+		Alterar(alterar: false);
+		Loading(isLoading: false);
+	}
+
+	public async void Excluir()
+	{
+		if (SelectedBancosContas == null || ((DomainBase)SelectedBancosContas).Id == 0L)
+		{
+			return;
+		}
+		if (await new BaseServico().BancosContasUtilizado(((DomainBase)SelectedBancosContas).Id))
+		{
+			await ShowMessage("NÃO PODE SER EXCLUÍDO POIS ESTÁ SENDO UTILIZADO EM UM LANÇAMENTO.");
+		}
+		else if (await ShowMessage("DESEJA REALMENTE EXCLUIR A CONTA " + SelectedBancosContas.Descricao + " PERMANENTEMENTE?", "SIM", "NÃO"))
+		{
+			Loading(isLoading: true);
+			if (!(await _bancosContasServico.Delete(SelectedBancosContas)))
+			{
+				Loading(isLoading: false);
+				return;
+			}
+			await SelecionaBancosDeContas();
+			Loading(isLoading: false);
+			ToggleSnackBar("CONTA EXCLUÍDA COM SUCESSO");
+		}
+	}
+
+	public async void ExcluirSaldo()
+	{
+		if (SelectedSaldo == null || ((DomainBase)SelectedSaldo).Id == 0L)
+		{
+			return;
+		}
+		if (Saldos.Count <= 1)
+		{
+			await ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO INICIAL DA CONTA.");
+		}
+		else
+		{
+			if (!(await ShowMessage("DESEJA REALMENTE EXCLUIR O SALDO PERMANENTEMENTE?", "SIM", "NÃO")))
+			{
+				return;
+			}
+			Loading(isLoading: true);
+			Saldo val = ((IEnumerable<Saldo>)Saldos).FirstOrDefault((Func<Saldo, bool>)delegate(Saldo x)
+			{
+				DateTime? dataFinal = x.DataFinal;
+				DateTime? dataInicio = SelectedSaldo.DataInicio;
+				if (dataFinal.HasValue != dataInicio.HasValue)
+				{
+					return false;
+				}
+				return !dataFinal.HasValue || dataFinal.GetValueOrDefault() == dataInicio.GetValueOrDefault();
+			});
+			if (val == null)
+			{
+				Loading(isLoading: false);
+				await ShowMessage("NÃO É POSSÍVEL EXCLUIR O SALDO DA CONTA.");
+				return;
+			}
+			val.DataFinal = null;
+			val.ValorFinal = null;
+			await _bancosContasServico.Save(val);
+			if (!_bancosContasServico.Sucesso)
+			{
+				Loading(isLoading: false);
+				return;
+			}
+			if (!(await _bancosContasServico.DeleteSaldo(SelectedSaldo)))
+			{
+				Loading(isLoading: false);
+				return;
+			}
+			CarregarSaldos(SelectedBancosContas);
+			Loading(isLoading: false);
+			ToggleSnackBar("SALDO EXCLUÍDO COM SUCESSO");
+			Loading(isLoading: false);
+		}
+	}
+
+	public void SelecionaBancosContas(BancosContas bancosContas)
+	{
+		Loading(isLoading: true);
+		SelectedBancosContas = ((IEnumerable<BancosContas>)BancosContasFiltrados).FirstOrDefault((Func<BancosContas, bool>)((BancosContas x) => ((DomainBase)x).Id == ((DomainBase)bancosContas).Id));
+		Loading(isLoading: false);
+	}
+
+	internal async Task<List<BancosContas>> Filtrar(string value)
+	{
+		return await Task.Run(() => FiltrarBancosContas(value));
+	}
+
+	public List<BancosContas> FiltrarBancosContas(string filter)
+	{
+		BancosContasFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<BancosContas>(BancosContas) : new ObservableCollection<BancosContas>(from x in BancosContas
+			where ValidationHelper.RemoveDiacritics(x.Descricao.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter))
+			orderby x.Ativo descending, x.Descricao
+			select x));
+		return BancosContasFiltrados.ToList();
+	}
+
+	public async Task FecharSaldo()
+	{
+		SelectedSaldo = await _bancosContasServico.Save(SelectedSaldo);
+		if (!_bancosContasServico.Sucesso)
+		{
+			return;
+		}
+		if (SelectedSaldo.DataFinal.HasValue && SelectedSaldo.ValorFinal.HasValue)
+		{
+			Saldo saldo = new Saldo
+			{
+				Conta = SelectedSaldo.Conta,
+				DataFinal = null,
+				DataInicio = SelectedSaldo.DataFinal.Value,
+				ValorFinal = null,
+				ValorInicio = SelectedSaldo.ValorFinal.Value
+			};
+			await _bancosContasServico.Save(saldo);
+			if (!_bancosContasServico.Sucesso)
+			{
+				return;
+			}
+		}
+		CarregarSaldos(SelectedBancosContas);
+		ToggleSnackBar("SALDO FECHADO COM SUCESSO");
+	}
+
+	public async Task<decimal> CalcularValor()
+	{
+		return (await _bancosContasServico.FecharSaldo(SelectedSaldo)).ValorFinal.GetValueOrDefault();
+	}
+}