feat: upload files

1 files changed, 604 insertions, 0 deletions

diff --git a/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs b/Gestor.Application/ViewModels/Financeiro/BancosContasViewModel.cs
new file mode 100644
index 0000000..e83a4eb
--- /dev/null
+++ b/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<Gestor.Model.Domain.Financeiro.BancosContas> _bancosContasFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.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<Gestor.Model.Domain.Financeiro.BancosContas> BancosContas

+		{

+			get;

+			set;

+		}

+

+		public ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> 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<Saldo> Saldos

+		{

+			get

+			{

+				return this._saldos;

+			}

+			set

+			{

+				this._saldos = value;

+				if (value != null && value.Count > 0)

+				{

+					this.SelectedSaldo = value.FirstOrDefault<Saldo>((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<decimal> 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>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == this._ultimoId);

+			if (bancosConta == null)

+			{

+				bancosConta = this.BancosContasFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>();

+			}

+			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<Saldo> saldos = await this._bancosContasServico.BuscarSaldos(banco.get_Id());

+				this.CorDoSaldo = new SolidColorBrush(Colors.Green);

+				this.SaldoAtual = string.Empty;

+				BancosContasViewModel observableCollection = this;

+				List<Saldo> saldos1 = saldos;

+				observableCollection.Saldos = new ObservableCollection<Saldo>(

+					from x in saldos1

+					orderby x.get_DataInicio() descending

+					select x);

+				if (this.Saldos.FirstOrDefault<Saldo>() != null)

+				{

+					Saldo saldo = new Saldo();

+					saldo.set_Conta(this.Saldos.First<Saldo>().get_Conta());

+					saldo.set_ValorInicio(this.Saldos.First<Saldo>().get_ValorInicio());

+					saldo.set_DataInicio(this.Saldos.First<Saldo>().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>((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<List<Gestor.Model.Domain.Financeiro.BancosContas>> Filtrar(string value)

+		{

+			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas = await Task.Run<List<Gestor.Model.Domain.Financeiro.BancosContas>>(() => this.FiltrarBancosContas(value));

+			return bancosContas;

+		}

+

+		public List<Gestor.Model.Domain.Financeiro.BancosContas> FiltrarBancosContas(string filter)

+		{

+			this.BancosContasFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(this.BancosContas) : new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(

+				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<Gestor.Model.Domain.Financeiro.BancosContas>();

+		}

+

+		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<Saldo>();

+			this.SelectedSaldo = null;

+			base.Alterar(true);

+		}

+

+		public async Task<List<KeyValuePair<string, string>>> Salvar()

+		{

+			List<KeyValuePair<string, string>> keyValuePairs;

+			Gestor.Model.Domain.Financeiro.BancosContas bancosConta;

+			List<KeyValuePair<string, string>> 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>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == bancosContas.get_Id());

+			base.Loading(false);

+		}

+

+		private async Task SelecionaBancosDeContas()

+		{

+			base.Loading(true);

+			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas = await this._bancosContasServico.BuscarBancos();

+			BancosContasViewModel list = this;

+			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas1 = bancosContas;

+			IOrderedEnumerable<Gestor.Model.Domain.Financeiro.BancosContas> ativo = 

+				from x in bancosContas1

+				orderby x.get_Ativo() descending

+				select x;

+			list.BancosContas = ativo.ThenBy<Gestor.Model.Domain.Financeiro.BancosContas, string>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Descricao()).ToList<Gestor.Model.Domain.Financeiro.BancosContas>();

+			this.BancosContasFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(this.BancosContas);

+			if (this.BancosContasFiltrados.Count <= 0)

+			{

+				this.SelectedBancosContas = new Gestor.Model.Domain.Financeiro.BancosContas();

+				this.Saldos = new ObservableCollection<Saldo>();

+				this.DataAbertura = null;

+				this.ValorAbertura = new decimal?(new decimal());

+				this.SaldoAtual = "";

+				base.Alterar(false);

+				base.EnableMenu = false;

+			}

+			else

+			{

+				this.SelecionaBancosContas(this.BancosContasFiltrados.First<Gestor.Model.Domain.Financeiro.BancosContas>());

+			}

+			Recursos.BancosContas = bancosContas;

+			base.Loading(false);

+		}

+

+		private async void UltimoSladoNaoAberto()

+		{

+			Saldo saldo = this.Saldos.ToList<Saldo>().Find((Saldo x) => {

+				DateTime? dataInicio = x.get_DataInicio();

+				DateTime? nullable = this.Saldos.Max<Saldo, DateTime?>((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<KeyValuePair<string, string>> Validate()

+		{

+			List<KeyValuePair<string, string>> keyValuePairs = new List<KeyValuePair<string, string>>();

+			if (this.BancosContas.Where<Gestor.Model.Domain.Financeiro.BancosContas>((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.Domain.Financeiro.BancosContas>())

+			{

+				Gestor.Model.Helper.ValidationHelper.AddValue<string, string>(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<string, string>(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<string, string>(keyValuePairs, "DataAbertura|ABERTURA", "DATA INVÁLIDA", true);

+				}

+				if (!this.ValorAbertura.HasValue)

+				{

+					Gestor.Model.Helper.ValidationHelper.AddValue<string, string>(keyValuePairs, "ValorAbertura|VALOR", "É NECESSÁRIO PREENCHER O VALOR DE ABERTURA DA CONTA.", true);

+				}

+			}

+			return keyValuePairs;

+		}

+	}

+}
\ No newline at end of file