path: root/Codemerx/Gestor.Application/ViewModels/Financeiro/ExtratoContaViewModel.cs

using ClosedXML.Excel;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Financeiro;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Helpers;
using Gestor.Model.Common;
using Gestor.Model.Domain.Configuracoes;
using Gestor.Model.Domain.Financeiro;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Relatorios;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Media;

namespace Gestor.Application.ViewModels.Financeiro
{
	public class ExtratoContaViewModel : BaseFinanceiroViewModel
	{
		private Geometry _maximizeRestore = Geometry.Parse((string)System.Windows.Application.Current.Resources["Restore"]);

		private string _head;

		private readonly FinanceiroServico _servico;

		private ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> _contas;

		private ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> _contasFilter;

		private Gestor.Model.Domain.Financeiro.BancosContas _selectedConta;

		private DateTime? _inicio;

		private DateTime? _fim;

		private static ObservableCollection<string> _bancosContas;

		private string _selectedBancosContas;

		private ObservableCollection<ExtratoConta> _extrato;

		private bool _saldoFinal;

		private bool _naoHaDados;

		public ObservableCollection<string> BancosContas
		{
			get
			{
				return ExtratoContaViewModel._bancosContas;
			}
			set
			{
				ExtratoContaViewModel._bancosContas = value;
				base.OnPropertyChanged("BancosContas");
			}
		}

		public ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> Contas
		{
			get
			{
				return this._contas;
			}
			set
			{
				this._contas = value;
				base.OnPropertyChanged("Contas");
			}
		}

		public ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas> ContasFilter
		{
			get
			{
				return this._contasFilter;
			}
			set
			{
				this._contasFilter = value;
				base.OnPropertyChanged("ContasFilter");
			}
		}

		public ObservableCollection<ExtratoConta> Extrato
		{
			get
			{
				return this._extrato;
			}
			set
			{
				this._extrato = value;
				this.NaoHaDados = (value == null ? true : value.Count == 0);
				base.OnPropertyChanged("Extrato");
			}
		}

		public DateTime? Fim
		{
			get
			{
				return this._fim;
			}
			set
			{
				this._fim = value;
				base.OnPropertyChanged("Fim");
			}
		}

		public string Head
		{
			get
			{
				return this._head;
			}
			set
			{
				this._head = value;
				base.OnPropertyChanged("Head");
			}
		}

		public DateTime? Inicio
		{
			get
			{
				return this._inicio;
			}
			set
			{
				this._inicio = value;
				base.OnPropertyChanged("Inicio");
			}
		}

		public Geometry MaximizeRestore
		{
			get
			{
				return this._maximizeRestore;
			}
			set
			{
				this._maximizeRestore = value;
				base.OnPropertyChanged("MaximizeRestore");
			}
		}

		public bool NaoHaDados
		{
			get
			{
				return this._naoHaDados;
			}
			set
			{
				this._naoHaDados = value;
				base.OnPropertyChanged("NaoHaDados");
			}
		}

		public bool SaldoFinal
		{
			get
			{
				return this._saldoFinal;
			}
			set
			{
				this._saldoFinal = value;
				base.OnPropertyChanged("SaldoFinal");
			}
		}

		public string SelectedBancosContas
		{
			get
			{
				return this._selectedBancosContas;
			}
			set
			{
				this._selectedBancosContas = value;
				if (value == null || this.Contas == null || this.Contas.Count <= 0)
				{
					return;
				}
				if (value == "TODOS")
				{
					this.ContasFilter = this.Contas;
				}
				else if (value == "ATIVOS")
				{
					this.ContasFilter = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>((
						from x in this.Contas
						where x.get_Ativo()
						select x).ToList<Gestor.Model.Domain.Financeiro.BancosContas>());
				}
				else if (value == "INATIVOS")
				{
					this.ContasFilter = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>((
						from x in this.Contas
						where !x.get_Ativo()
						select x).ToList<Gestor.Model.Domain.Financeiro.BancosContas>());
				}
				base.OnPropertyChanged("SelectedBancosContas");
			}
		}

		public Gestor.Model.Domain.Financeiro.BancosContas SelectedConta
		{
			get
			{
				return this._selectedConta;
			}
			set
			{
				this._selectedConta = value;
				base.OnPropertyChanged("SelectedConta");
			}
		}

		static ExtratoContaViewModel()
		{
			ExtratoContaViewModel._bancosContas = new ObservableCollection<string>()
			{
				"TODOS",
				"ATIVOS",
				"INATIVOS"
			};
		}

		public ExtratoContaViewModel(long id)
		{
			this._maximizeRestore = Geometry.Parse((string)System.Windows.Application.Current.Resources["Restore"]);
			DateTime date = Funcoes.GetNetworkTime().Date;
			int year = date.Year;
			date = Funcoes.GetNetworkTime().Date;
			this._inicio = new DateTime?(new DateTime(year, date.Month, 1));
			this._fim = new DateTime?(Funcoes.GetNetworkTime());
			this._selectedBancosContas = "TODOS";
			base();
			this._servico = new FinanceiroServico();
			this.BuscaInicial(id);
		}

		private async void BuscaInicial(long id)
		{
			Gestor.Model.Domain.Financeiro.BancosContas bancosConta;
			base.Loading(true);
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas = await (new BancosContasServico()).BuscarBancos();
			ExtratoContaViewModel observableCollection = this;
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas1 = bancosContas;
			observableCollection.Contas = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(
				from x in bancosContas1
				orderby x.get_Descricao()
				select x);
			ExtratoContaViewModel extratoContaViewModel = this;
			List<Gestor.Model.Domain.Financeiro.BancosContas> bancosContas2 = bancosContas;
			extratoContaViewModel.ContasFilter = new ObservableCollection<Gestor.Model.Domain.Financeiro.BancosContas>(
				from x in bancosContas2
				orderby x.get_Descricao()
				select x);
			ExtratoContaViewModel extratoContaViewModel1 = this;
			bancosConta = (id > (long)0 ? this.Contas.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>((Gestor.Model.Domain.Financeiro.BancosContas x) => x.get_Id() == id) : this.Contas.FirstOrDefault<Gestor.Model.Domain.Financeiro.BancosContas>());
			extratoContaViewModel1.SelectedConta = bancosConta;
			await this.GerarRelatorio();
			base.Loading(false);
		}

		public async Task GerarExcel()
		{
			string str;
			string str1;
			if (this.Extrato == null || this.Extrato.Count == 0)
			{
				base.ShowMessage("NÃO HÁ DADOS PARA A IMPRESSÃO EM EXCEL", "OK", "", false);
			}
			else
			{
				List<ExtratoConta> list = this.Extrato.ToList<ExtratoConta>();
				string tempPath = "";
				str1 = "";
				List<ConfiguracaoSistema> configuracoes = Recursos.Configuracoes;
				if (!configuracoes.Any<ConfiguracaoSistema>((ConfiguracaoSistema x) => x.get_Configuracao() == 41))
				{
					tempPath = Path.GetTempPath();
					str1 = string.Format("{0}{1}.xlsx", tempPath, Guid.NewGuid());
				}
				else
				{
					using (FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog())
					{
						if (DialogResult.OK == folderBrowserDialog.ShowDialog())
						{
							tempPath = string.Concat(folderBrowserDialog.SelectedPath, "\\");
							Directory.CreateDirectory(tempPath);
						}
						else
						{
							str1 = null;
							return;
						}
					}
					string[] descricao = new string[] { tempPath, "EXTRATO CONTA - ", this.SelectedConta.get_Descricao(), " ", null, null };
					DateTime date = Functions.GetNetworkTime().Date;
					descricao[4] = date.ToShortDateString().Replace("/", "");
					descricao[5] = ".xlsx";
					str1 = string.Concat(descricao);
				}
				XLWorkbook xLWorkbook = new XLWorkbook();
				string str2 = string.Concat("EXTRATO CONTA - ", this.SelectedConta.get_Descricao());
				str = (str2.Length < 30 ? str2 : str2.Substring(0, 30));
				str2 = str;
				await Funcoes.GerarXls<ExtratoConta>(xLWorkbook, str2, list, new List<string>()).SaveAs(str1);
				Process.Start(str1);
			}
			str1 = null;
		}

		public async Task GerarRelatorio()
		{
			DateTime? dataInicio;
			bool flag;
			Sinal sinal;
			Sinal sinal1;
			string str;
			ExtratoContaViewModel.u003cu003ec__DisplayClass52_0 variable;
			if (this.SelectedConta != null && this.SelectedConta.get_Id() != 0)
			{
				DateTime? inicio = this.Inicio;
				if (inicio.HasValue)
				{
					inicio = this.Fim;
					if (inicio.HasValue)
					{
						BancosContasServico bancosContasServico = new BancosContasServico();
						Saldo saldo = await bancosContasServico.BuscarSaldoInicial(this.SelectedConta.get_Id());
						if (saldo != null)
						{
							dataInicio = saldo.get_DataInicio();
						}
						else
						{
							dataInicio = null;
						}
						inicio = dataInicio;
						DateTime? fim = this.Inicio;
						flag = (inicio.HasValue & fim.HasValue ? inicio.GetValueOrDefault() > fim.GetValueOrDefault() : false);
						if (!flag)
						{
							FinanceiroServico financeiroServico = this._servico;
							fim = this.Inicio;
							DateTime value = fim.Value;
							fim = this.Fim;
							List<ExtratoConta> extratoContas2 = await financeiroServico.BuscarLancamentosPorConta(value, fim.Value, this.SelectedConta.get_Id());
							List<ExtratoConta> extratoContas3 = extratoContas2;
							BancosContasServico bancosContasServico1 = bancosContasServico;
							fim = this.Inicio;
							Saldo saldo1 = await bancosContasServico1.BuscarSaldo(fim.Value, this.SelectedConta.get_Id());
							if (extratoContas3.Count != 0)
							{
								if (saldo1 == null)
								{
									Saldo saldo2 = new Saldo();
									saldo2.set_Conta(this.SelectedConta);
									saldo2.set_DataInicio(this.Inicio);
									saldo2.set_ValorInicio(decimal.Zero);
									saldo1 = saldo2;
								}
								fim = this.Inicio;
								saldo1.set_DataFinal(new DateTime?(fim.Value));
								decimal num1 = new decimal();
								saldo1.set_ValorFinal(new decimal?(num1));
								saldo1 = await bancosContasServico.FecharSaldo(saldo1);
								List<ExtratoConta> extratoContas4 = new List<ExtratoConta>();
								ExtratoConta extratoContum2 = new ExtratoConta();
								fim = this.Inicio;
								extratoContum2.set_Baixa(new DateTime?(fim.Value));
								extratoContum2.set_Fornecedor("SALDO INICIAL");
								decimal? valorFinal = saldo1.get_ValorFinal();
								extratoContum2.set_Valor(new decimal?(valorFinal.GetValueOrDefault()));
								valorFinal = saldo1.get_ValorFinal();
								sinal = (valorFinal.GetValueOrDefault() < decimal.Zero ? 1 : 0);
								extratoContum2.set_Sinal(sinal);
								extratoContum2.set_Bold(true);
								ExtratoConta extratoContum3 = extratoContum2;
								extratoContas4.Add(extratoContum3);
								decimal? valor = extratoContum3.get_Valor();
								List<ExtratoConta> extratoContas5 = extratoContas3;
								IOrderedEnumerable<ExtratoConta> extratoContas6 = 
									from x in extratoContas5
									orderby x.get_Baixa()
									select x;
								(
									from x in extratoContas6
									group x by x.get_Baixa()).ToList<IGrouping<DateTime?, ExtratoConta>>().ForEach((IGrouping<DateTime?, ExtratoConta> g) => {
									decimal? nullable;
									decimal? nullable1;
									List<ExtratoConta> list = extratoContas3.Where<ExtratoConta>((ExtratoConta x) => {
										DateTime? baixa = x.get_Baixa();
										DateTime? key = g.Key;
										if (baixa.HasValue != key.HasValue)
										{
											return false;
										}
										if (!baixa.HasValue)
										{
											return true;
										}
										return baixa.GetValueOrDefault() == key.GetValueOrDefault();
									}).ToList<ExtratoConta>();
									ExtratoConta extratoContum = new ExtratoConta();
									extratoContum.set_Baixa(g.Key);
									extratoContum.set_Fornecedor("SALDO FINAL DO DIA");
									decimal? nullable2 = valor;
									List<ExtratoConta> extratoContas = list;
									Func<ExtratoConta, decimal?> u003cu003e9_524 = ExtratoContaViewModel.u003cu003ec.u003cu003e9__52_4;
									if (u003cu003e9_524 == null)
									{
										u003cu003e9_524 = (ExtratoConta x) => x.get_Valor();
										ExtratoContaViewModel.u003cu003ec.u003cu003e9__52_4 = u003cu003e9_524;
									}
									decimal? nullable3 = extratoContas.Sum<ExtratoConta>(u003cu003e9_524);
									if (nullable2.HasValue & nullable3.HasValue)
									{
										nullable1 = new decimal?(nullable2.GetValueOrDefault() + nullable3.GetValueOrDefault());
									}
									else
									{
										nullable = null;
										nullable1 = nullable;
									}
									extratoContum.set_Valor(nullable1);
									nullable2 = valor;
									List<ExtratoConta> extratoContas1 = list;
									Func<ExtratoConta, decimal?> u003cu003e9_525 = ExtratoContaViewModel.u003cu003ec.u003cu003e9__52_5;
									if (u003cu003e9_525 == null)
									{
										u003cu003e9_525 = (ExtratoConta x) => x.get_Valor();
										ExtratoContaViewModel.u003cu003ec.u003cu003e9__52_5 = u003cu003e9_525;
									}
									nullable = extratoContas1.Sum<ExtratoConta>(u003cu003e9_525);
									nullable3 = (nullable2.HasValue & nullable.HasValue ? new decimal?(nullable2.GetValueOrDefault() + nullable.GetValueOrDefault()) : null);
									decimal num = new decimal();
									extratoContum.set_Sinal(((nullable3.GetValueOrDefault() < num) & nullable3.HasValue ? 1 : 0));
									extratoContum.set_Bold(true);
									ExtratoConta extratoContum1 = extratoContum;
									if (!this.SaldoFinal)
									{
										extratoContas4.AddRange(list);
									}
									extratoContas4.Add(extratoContum1);
									valor = extratoContum1.get_Valor();
								});
								List<ExtratoConta> extratoContas7 = extratoContas4;
								ExtratoConta extratoContum4 = new ExtratoConta();
								fim = this.Fim;
								extratoContum4.set_Baixa(new DateTime?(fim.Value));
								extratoContum4.set_Fornecedor("SALDO FINAL");
								extratoContum4.set_Valor(valor);
								valorFinal = valor;
								num1 = new decimal();
								sinal1 = ((valorFinal.GetValueOrDefault() < num1) & valorFinal.HasValue ? 1 : 0);
								extratoContum4.set_Sinal(sinal1);
								extratoContum4.set_Bold(true);
								extratoContas7.Add(extratoContum4);
								this.Extrato = new ObservableCollection<ExtratoConta>(extratoContas4);
								bancosContasServico = null;
							}
							else
							{
								this.NaoHaDados = true;
								variable = null;
								return;
							}
						}
						else
						{
							ExtratoContaViewModel extratoContaViewModel = this;
							string descricao = saldo.get_Conta().get_Descricao();
							fim = saldo.get_DataInicio();
							if (fim.HasValue)
							{
								str = fim.GetValueOrDefault().ToString("dd/MM/yyyy");
							}
							else
							{
								str = null;
							}
							extratoContaViewModel.ShowMessage(string.Concat("DATA DE INÍCIO É MENOR QUE A CRIAÇÃO DA CONTA ", descricao, ",\nDATA DE ABERTURA ", str), "OK", "", false);
							this.NaoHaDados = true;
							variable = null;
							return;
						}
					}
				}
			}
			variable = null;
		}

		public void LimparRelatorio()
		{
			this.Extrato = null;
		}

		public async Task Print()
		{
			DateTime dateTime;
			DateTime dateTime1;
			string str;
			if (this.Extrato == null || this.Extrato.Count == 0)
			{
				base.ShowMessage("NÃO HÁ DADOS PARA A IMPRESSÃO", "OK", "", false);
			}
			else
			{
				string str1 = await Funcoes.GenerateTable<ExtratoConta>(this.Extrato.ToList<ExtratoConta>(), new List<string>(), false, false, "", null);
				TipoRelatorio tipoRelatorio = new TipoRelatorio();
				tipoRelatorio.set_Nome(string.Concat("EXTRATO CONTA - ", this.SelectedConta.get_Descricao()));
				DateTime? inicio = this.Inicio;
				dateTime = (inicio.HasValue ? inicio.GetValueOrDefault() : DateTime.MinValue);
				tipoRelatorio.set_Inicio(dateTime);
				inicio = this.Fim;
				dateTime1 = (inicio.HasValue ? inicio.GetValueOrDefault() : DateTime.MinValue);
				tipoRelatorio.set_Fim(dateTime1);
				TipoRelatorio tipoRelatorio1 = tipoRelatorio;
				TipoRelatorio tipoRelatorio2 = tipoRelatorio1;
				str = (tipoRelatorio1.get_Nome().Length < 30 ? tipoRelatorio1.get_Nome() : tipoRelatorio1.get_Nome().Substring(0, 30));
				tipoRelatorio2.set_Nome(str);
				string str2 = Funcoes.ExportarHtml(tipoRelatorio1, str1, "60", "portrait", false, "");
				string tempPath = Path.GetTempPath();
				string str3 = string.Format("{0}{1}_{2:ddMMyyyyhhmmss}.html", tempPath, (new Regex(string.Concat("[", Regex.Escape(string.Concat(new string(Path.GetInvalidFileNameChars()), new string(Path.GetInvalidPathChars()))), "]"))).Replace(tipoRelatorio1.get_Nome(), ""), Funcoes.GetNetworkTime());
				StreamWriter streamWriter = new StreamWriter(str3, true, Encoding.UTF8);
				streamWriter.Write(str2);
				streamWriter.Close();
				Process.Start(str3);
			}
		}
	}
}