path: root/Decompiler/Gestor.Application.ViewModels.Ferramentas/NotaFiscalViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos;
using Gestor.Application.Servicos.Ferramentas;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Validation;
using Gestor.Model.Common;
using Gestor.Model.Domain.Configuracoes;
using Gestor.Model.Domain.Ferramentas;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;

namespace Gestor.Application.ViewModels.Ferramentas;

public class NotaFiscalViewModel : BaseSegurosViewModel
{
	private readonly NotaFiscalServico _servico;

	private readonly ServicoExtrato _servicoExtrato;

	private bool _apelido;

	private List<Estipulante> _estipulantes;

	private List<Seguradora> _seguradoras;

	private ObservableCollection<NotaFiscal> _notasFiscaisFiltrados = new ObservableCollection<NotaFiscal>();

	private bool _isExpanded;

	private string _numExtrato;

	private NotaFiscal _selectedNotaFiscal;

	public NotaFiscal CancelNotaFiscal;

	public bool Apelido
	{
		get
		{
			return _apelido;
		}
		set
		{
			_apelido = value;
			OnPropertyChanged("Apelido");
		}
	}

	public List<Estipulante> Estipulantes
	{
		get
		{
			return _estipulantes;
		}
		set
		{
			_estipulantes = value;
			OnPropertyChanged("Estipulantes");
		}
	}

	public List<Seguradora> Seguradoras
	{
		get
		{
			return _seguradoras;
		}
		set
		{
			_seguradoras = value;
			OnPropertyChanged("Seguradoras");
		}
	}

	public ObservableCollection<NotaFiscal> NotasFiscaisFiltrados
	{
		get
		{
			return _notasFiscaisFiltrados;
		}
		set
		{
			_notasFiscaisFiltrados = value;
			IsExpanded = value != null && value.Count > 0;
			OnPropertyChanged("NotasFiscaisFiltrados");
		}
	}

	public bool IsExpanded
	{
		get
		{
			return _isExpanded;
		}
		set
		{
			_isExpanded = value;
			OnPropertyChanged("IsExpanded");
		}
	}

	public string NumExtrato
	{
		get
		{
			return _numExtrato;
		}
		set
		{
			_numExtrato = value;
			OnPropertyChanged("NumExtrato");
		}
	}

	public List<NotaFiscal> NotasFiscais { get; set; }

	public NotaFiscal SelectedNotaFiscal
	{
		get
		{
			return _selectedNotaFiscal;
		}
		set
		{
			_selectedNotaFiscal = value;
			WorkOnSelectedNotaFiscal(value);
			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
			OnPropertyChanged("SelectedNotaFiscal");
		}
	}

	public NotaFiscalViewModel()
	{
		_servicoExtrato = new ServicoExtrato();
		_servico = new NotaFiscalServico();
		Seguradoras = Recursos.Seguradoras.Where((Seguradora x) => x.Ativo).ToList();
		Estipulantes = Recursos.Estipulantes.Where((Estipulante e) => e.Ativo).ToList();
		Apelido = Recursos.Configuracoes.Any((ConfiguracaoSistema x) => (int)x.Configuracao == 6);
		base.EnableMenu = true;
		Seleciona();
	}

	private async void Seleciona()
	{
		Loading(isLoading: true);
		await PermissaoTela((TipoTela)55);
		await SelecionaNotaFiscal();
		Loading(isLoading: false);
	}

	public async Task SelecionaNotaFiscal()
	{
		Loading(isLoading: true);
		NotasFiscais = (await _servico.BuscarNotasFiscais()).OrderBy((NotaFiscal x) => x.Seguradora.Nome).ToList();
		NotasFiscaisFiltrados = new ObservableCollection<NotaFiscal>(NotasFiscais);
		SelectedNotaFiscal = NotasFiscaisFiltrados.FirstOrDefault();
		Loading(isLoading: false);
	}

	public async Task<List<NotaFiscal>> Filtrar(string value)
	{
		return await Task.Run(() => FiltrarNotaFiscal(value));
	}

	public List<NotaFiscal> FiltrarNotaFiscal(string filter)
	{
		NotasFiscaisFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<NotaFiscal>(NotasFiscais) : new ObservableCollection<NotaFiscal>(from x in NotasFiscais
			where ValidationHelper.RemoveDiacritics(x.Seguradora.Nome.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter)) || ValidationHelper.RemoveDiacritics(x.ValorBruto.ToString(CultureInfo.InvariantCulture).Trim()).Contains(ValidationHelper.RemoveDiacritics(filter)) || ValidationHelper.RemoveDiacritics(x.Data.ToString().Trim()).Contains(ValidationHelper.RemoveDiacritics(filter))
			orderby x.Seguradora.Nome
			select x));
		return NotasFiscaisFiltrados.ToList();
	}

	public void Incluir()
	{
		//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_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		SelectedNotaFiscal = new NotaFiscal
		{
			Seguradora = new Seguradora(),
			Estipulante = new Estipulante(),
			Iss = 0m,
			ValorLiquido = 0m,
			ValorBruto = 0m,
			Extrato = ""
		};
		Alterar(alterar: true);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar()
	{
		List<KeyValuePair<string, string>> list = SelectedNotaFiscal.Validate();
		if (list.Count > 0)
		{
			return list;
		}
		string acao = ((((DomainBase)SelectedNotaFiscal).Id == 0L) ? "INCLUIU" : "ALTEROU");
		NotaFiscal selectedNotaFiscal = SelectedNotaFiscal;
		int num;
		if (selectedNotaFiscal == null)
		{
			num = 0;
		}
		else
		{
			Estipulante estipulante = selectedNotaFiscal.Estipulante;
			num = ((((estipulante != null) ? new long?(((DomainBase)estipulante).Id) : null) <= 0) ? 1 : 0);
		}
		if (num != 0)
		{
			SelectedNotaFiscal.Estipulante = null;
		}
		NotaFiscal value = await _servico.Save(SelectedNotaFiscal);
		if (!_servico.Sucesso)
		{
			return null;
		}
		RegistrarAcao($"{acao} NOTA FISCAL DE ID \"{((DomainBase)value).Id}\"", ((DomainBase)value).Id, (TipoTela)55, string.Format("SEGURADORA: {0}\nDATA: {1}\nBRUTO: {2:c}\nISS: {3:c}\nLÍQUIDO: {4:c}", value.Seguradora.Nome, (!value.Data.HasValue) ? "-" : $"{value.Data:d}", value.ValorBruto, value.Iss, value.ValorLiquido));
		if (NotasFiscais.Any((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)value).Id))
		{
			DomainBase.Copy<NotaFiscal, NotaFiscal>(NotasFiscais.First((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)value).Id), value);
		}
		else
		{
			NotasFiscais.Add(value);
		}
		if (NotasFiscaisFiltrados.Any((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)value).Id))
		{
			DomainBase.Copy<NotaFiscal, NotaFiscal>(NotasFiscaisFiltrados.First((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)value).Id), value);
		}
		else
		{
			NotasFiscaisFiltrados.Add(value);
		}
		NotasFiscaisFiltrados = new ObservableCollection<NotaFiscal>(NotasFiscaisFiltrados);
		WorkOnSelectedNotaFiscal(value, registrar: false);
		Alterar(alterar: false);
		ToggleSnackBar("NOTA FISCAL SALVA COM SUCESSO");
		return null;
	}

	public async Task SalvarLote(List<NotaFiscal> notas)
	{
		foreach (NotaFiscal nota in notas)
		{
			bool flag = nota.IdExtrato.HasValue;
			if (flag)
			{
				flag = await _servico.Cadatrada(nota.IdExtrato.Value);
			}
			if (!flag)
			{
				SelectedNotaFiscal = nota;
				await Salvar();
			}
		}
		ToggleSnackBar("NOTAS FISCAIS SALVAS COM SUCESSO");
	}

	public void CancelarAlteracao()
	{
		if (CancelNotaFiscal != null && NotasFiscais.Any((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)CancelNotaFiscal).Id))
		{
			DomainBase.Copy<NotaFiscal, NotaFiscal>(NotasFiscais.First((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)CancelNotaFiscal).Id), CancelNotaFiscal);
			if (NotasFiscaisFiltrados.Count > 0 && NotasFiscaisFiltrados.Any((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)CancelNotaFiscal).Id))
			{
				DomainBase.Copy<NotaFiscal, NotaFiscal>(NotasFiscaisFiltrados.First((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)CancelNotaFiscal).Id), CancelNotaFiscal);
			}
			else
			{
				NotasFiscaisFiltrados.Add(CancelNotaFiscal);
			}
			NotasFiscaisFiltrados = new ObservableCollection<NotaFiscal>(NotasFiscaisFiltrados);
			SelectedNotaFiscal = NotasFiscaisFiltrados.First((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)CancelNotaFiscal).Id);
		}
		else
		{
			Incluir();
		}
		Alterar(alterar: false);
	}

	public async void Excluir()
	{
		if (SelectedNotaFiscal != null && ((DomainBase)SelectedNotaFiscal).Id != 0L && await ShowMessage("DESEJA REALMENTE EXCLUIR A NOTA FISCAL DA " + SelectedNotaFiscal.Seguradora.Nome + "?", "SIM", "NÃO"))
		{
			Loading(isLoading: true);
			if (!(await _servico.Delete(SelectedNotaFiscal)))
			{
				Loading(isLoading: false);
				return;
			}
			RegistrarAcao($"EXCLUIU NOTA FISCAL DE ID \"{((DomainBase)SelectedNotaFiscal).Id}\"", ((DomainBase)SelectedNotaFiscal).Id, (TipoTela)55, string.Format("SEGURADORA: {0}\nDATA: {1}\nBRUTO: {2:c}\nISS: {3:c}\nLÍQUIDO: {4:c}", SelectedNotaFiscal.Seguradora.Nome, (!SelectedNotaFiscal.Data.HasValue) ? "-" : $"{SelectedNotaFiscal.Data:d}", SelectedNotaFiscal.ValorBruto, SelectedNotaFiscal.Iss, SelectedNotaFiscal.ValorLiquido));
			await SelecionaNotaFiscal();
			Loading(isLoading: false);
			ToggleSnackBar("RECIBO EXCLUÍDO COM SUCESSO");
		}
	}

	private async Task WorkOnSelectedNotaFiscal(NotaFiscal value, bool registrar = true)
	{
		CancelNotaFiscal = (NotaFiscal)((value == null || ((DomainBase)value).Id == 0L) ? ((object)CancelNotaFiscal) : ((object)(NotaFiscal)((DomainBase)value).Clone()));
		if (value == null || ((DomainBase)value).Id == 0L || (LastAccessId == ((DomainBase)value).Id && (int)LastAccessTela == 55))
		{
			return;
		}
		if (registrar)
		{
			RegistrarAcao($"ACESSOU NOTA FISCAL DE ID \"{((DomainBase)value).Id}\"", ((DomainBase)value).Id, (TipoTela)55, string.Format("SEGURADORA: {0}\nDATA: {1}\nBRUTO: {2:c}\nISS: {3:c}\nLÍQUIDO: {4:c}", value.Seguradora.Nome, (!value.Data.HasValue) ? "-" : $"{value.Data:d}", value.ValorBruto, value.Iss, value.ValorLiquido));
		}
		LastAccessId = ((DomainBase)value).Id;
		LastAccessTela = (TipoTela)55;
		if (string.IsNullOrEmpty(SelectedNotaFiscal.Extrato))
		{
			NotaFiscal selectedNotaFiscal = SelectedNotaFiscal;
			string extrato = ((!SelectedNotaFiscal.IdExtrato.HasValue) ? "" : (await _servicoExtrato.BuscarNumExtrato(SelectedNotaFiscal.IdExtrato)));
			selectedNotaFiscal.Extrato = extrato;
		}
		NotaFiscal selectedNotaFiscal2 = SelectedNotaFiscal;
		if (((selectedNotaFiscal2 != null) ? new long?(((DomainBase)selectedNotaFiscal2).Id) : null) != ((DomainBase)value).Id)
		{
			SelectedNotaFiscal = ((IEnumerable<NotaFiscal>)NotasFiscaisFiltrados).FirstOrDefault((Func<NotaFiscal, bool>)((NotaFiscal x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
		}
	}

	public async Task<decimal> BuscarImposto()
	{
		List<Imposto> source = await new ImpostoServico().Buscar(true);
		Imposto? obj = ((IEnumerable<Imposto>)source).FirstOrDefault((Func<Imposto, bool>)((Imposto x) => x.Seguradora != null && ((DomainBase)x.Seguradora).Id == ((DomainBase)SelectedNotaFiscal.Seguradora).Id && x.Ramo == null)) ?? ((IEnumerable<Imposto>)source).FirstOrDefault((Func<Imposto, bool>)((Imposto x) => x.Seguradora == null && x.Ramo == null));
		return (obj != null) ? obj.Iss : 0m;
	}
}