using Assinador.Infrastructure.Helpers;
using ClosedXML.Excel;
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.Configuracoes;
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.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Gestor.Application.ViewModels.Financeiro
{
	public class FornecedorViewModel : BaseFinanceiroViewModel
	{
		private readonly FornecedorServico _servico;

		private List<Gestor.Model.Domain.Financeiro.Planos> _planos;

		private ObservableCollection<Gestor.Model.Domain.Financeiro.Planos> _planosFiltrados;

		private List<BancosContas> _contas;

		private ObservableCollection<BancosContas> _contasFiltradas;

		private List<Centro> _centros;

		private ObservableCollection<Centro> _centrosFiltrados;

		private ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor> _fornecedorFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor>();

		private bool _isExpanded;

		private Gestor.Model.Domain.Financeiro.Fornecedor _selectedFornecedor;

		private string _anotacoes;

		private long _ultimoId;

		public Gestor.Model.Domain.Financeiro.Fornecedor CancelProduto;

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

		public List<Centro> Centros
		{
			get
			{
				return this._centros;
			}
			set
			{
				this._centros = value;
				base.OnPropertyChanged("Centros");
			}
		}

		public ObservableCollection<Centro> CentrosFiltrados
		{
			get
			{
				return this._centrosFiltrados;
			}
			set
			{
				this._centrosFiltrados = value;
				base.OnPropertyChanged("CentrosFiltrados");
			}
		}

		public List<BancosContas> Contas
		{
			get
			{
				return this._contas;
			}
			set
			{
				this._contas = value;
				base.OnPropertyChanged("Contas");
			}
		}

		public ObservableCollection<BancosContas> ContasFiltradas
		{
			get
			{
				return this._contasFiltradas;
			}
			set
			{
				this._contasFiltradas = value;
				base.OnPropertyChanged("ContasFiltradas");
			}
		}

		public List<Gestor.Model.Domain.Financeiro.Fornecedor> Fornecedor
		{
			get;
			set;
		}

		public ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor> FornecedorFiltrados
		{
			get
			{
				return this._fornecedorFiltrados;
			}
			set
			{
				this._fornecedorFiltrados = value;
				this.IsExpanded = (value != null ? value.Count > 0 : false);
				base.OnPropertyChanged("FornecedorFiltrados");
			}
		}

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

		public List<Gestor.Model.Domain.Financeiro.Planos> Planos
		{
			get
			{
				return this._planos;
			}
			set
			{
				this._planos = value;
				base.OnPropertyChanged("Planos");
			}
		}

		public ObservableCollection<Gestor.Model.Domain.Financeiro.Planos> PlanosFiltrados
		{
			get
			{
				return this._planosFiltrados;
			}
			set
			{
				this._planosFiltrados = value;
				base.OnPropertyChanged("PlanosFiltrados");
			}
		}

		public Gestor.Model.Domain.Financeiro.Fornecedor SelectedFornecedor
		{
			get
			{
				return this._selectedFornecedor;
			}
			set
			{
				long? nullable;
				this._selectedFornecedor = value;
				if (value != null)
				{
					nullable = new long?(value.get_Id());
				}
				else
				{
					nullable = null;
				}
				base.VerificarEnables(nullable);
				this.Anotacoes = string.Empty;
				this._ultimoId = (value == null || value.get_Id() <= (long)0 ? this._ultimoId : value.get_Id());
				base.OnPropertyChanged("SelectedFornecedor");
			}
		}

		public FornecedorViewModel()
		{
			this._servico = new FornecedorServico();
			base.EnableMenu = true;
			this.BuscaIncial();
		}

		private async void BuscaIncial()
		{
			base.Loading(true);
			await base.PermissaoTela(24);
			this.Planos = await (new PlanoServico()).BuscarPlanos();
			FornecedorViewModel observableCollection = this;
			List<Gestor.Model.Domain.Financeiro.Planos> planos = this.Planos;
			IEnumerable<Gestor.Model.Domain.Financeiro.Planos> ativo = 
				from x in planos
				where x.get_Ativo()
				select x;
			observableCollection.PlanosFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.Planos>(
				from x in ativo
				orderby x.get_Descricao()
				select x);
			this.Contas = await (new BancosContasServico()).BuscarBancos();
			FornecedorViewModel fornecedorViewModel = this;
			List<BancosContas> contas = this.Contas;
			IEnumerable<BancosContas> bancosContas = 
				from x in contas
				where x.get_Ativo()
				select x;
			fornecedorViewModel.ContasFiltradas = new ObservableCollection<BancosContas>(
				from x in bancosContas
				orderby x.get_Descricao()
				select x);
			this.Centros = await (new CentroServico()).BuscarCentros();
			FornecedorViewModel observableCollection1 = this;
			List<Centro> centros = this.Centros;
			IEnumerable<Centro> ativo1 = 
				from x in centros
				where x.get_Ativo()
				select x;
			observableCollection1.CentrosFiltrados = new ObservableCollection<Centro>(
				from x in ativo1
				orderby x.get_Descricao()
				select x);
			await this.SelecionaFornecedor();
			this.SelectedFornecedor = this.FornecedorFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.Fornecedor>();
			base.Loading(false);
		}

		public async void CancelarAlteracao()
		{
			base.Loading(true);
			base.Alterar(false);
			if (this.SelectedFornecedor.get_Id() > (long)0)
			{
				await this.SelecionaFornecedor();
			}
			this.SelectedFornecedor = this.FornecedorFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.Fornecedor>((Gestor.Model.Domain.Financeiro.Fornecedor x) => x.get_Id() == this._ultimoId);
			base.Loading(false);
		}

		public void Copiar(Cliente cliente)
		{
			TipoTelefone? nullable;
			string str;
			string str1;
			string str2;
			string str3;
			string str4;
			string str5;
			string str6;
			TipoTelefone? tipo;
			string str7;
			string str8;
			TipoTelefone? tipo1;
			string str9;
			string str10;
			string str11;
			if (this.SelectedFornecedor == null)
			{
				this.Incluir();
			}
			this.SelectedFornecedor.set_Nome(cliente.get_Nome());
			this.SelectedFornecedor.set_Documento(cliente.get_Documento());
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str = null;
			}
			else
			{
				ClienteEndereco clienteEndereco = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco != null)
				{
					string cep = clienteEndereco.get_Cep();
					if (cep != null)
					{
						str = cep.Trim();
					}
					else
					{
						str = null;
					}
				}
				else
				{
					str = null;
				}
			}
			selectedFornecedor.set_Cep(str);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str1 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco1 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco1 != null)
				{
					string endereco = clienteEndereco1.get_Endereco();
					if (endereco != null)
					{
						str1 = endereco.Trim();
					}
					else
					{
						str1 = null;
					}
				}
				else
				{
					str1 = null;
				}
			}
			fornecedor.set_Endereco(str1);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor1 = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str2 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco2 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco2 != null)
				{
					string numero = clienteEndereco2.get_Numero();
					if (numero != null)
					{
						str2 = numero.Trim();
					}
					else
					{
						str2 = null;
					}
				}
				else
				{
					str2 = null;
				}
			}
			selectedFornecedor1.set_Numero(str2);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor1 = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str3 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco3 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco3 != null)
				{
					string complemento = clienteEndereco3.get_Complemento();
					if (complemento != null)
					{
						str3 = complemento.Trim();
					}
					else
					{
						str3 = null;
					}
				}
				else
				{
					str3 = null;
				}
			}
			fornecedor1.set_Complemento(str3);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor2 = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str4 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco4 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco4 != null)
				{
					string bairro = clienteEndereco4.get_Bairro();
					if (bairro != null)
					{
						str4 = bairro.Trim();
					}
					else
					{
						str4 = null;
					}
				}
				else
				{
					str4 = null;
				}
			}
			selectedFornecedor2.set_Bairro(str4);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor2 = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str5 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco5 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco5 != null)
				{
					string cidade = clienteEndereco5.get_Cidade();
					if (cidade != null)
					{
						str5 = cidade.Trim();
					}
					else
					{
						str5 = null;
					}
				}
				else
				{
					str5 = null;
				}
			}
			fornecedor2.set_Cidade(str5);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor3 = this.SelectedFornecedor;
			if (cliente.get_Enderecos() == null || !cliente.get_Enderecos().Any<ClienteEndereco>())
			{
				str6 = null;
			}
			else
			{
				ClienteEndereco clienteEndereco6 = cliente.get_Enderecos().First<ClienteEndereco>();
				if (clienteEndereco6 != null)
				{
					string estado = clienteEndereco6.get_Estado();
					if (estado != null)
					{
						str6 = estado.Trim();
					}
					else
					{
						str6 = null;
					}
				}
				else
				{
					str6 = null;
				}
			}
			selectedFornecedor3.set_Estado(str6);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor3 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || !cliente.get_Telefones().Any<ClienteTelefone>())
			{
				nullable = null;
				tipo = nullable;
			}
			else
			{
				tipo = cliente.get_Telefones().First<ClienteTelefone>().get_Tipo();
			}
			fornecedor3.set_TipoTelefone1(tipo);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor4 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || !cliente.get_Telefones().Any<ClienteTelefone>())
			{
				str7 = null;
			}
			else
			{
				string prefixo = cliente.get_Telefones().First<ClienteTelefone>().get_Prefixo();
				if (prefixo != null)
				{
					str7 = prefixo.Trim();
				}
				else
				{
					str7 = null;
				}
			}
			selectedFornecedor4.set_Prefixo1(str7);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor4 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || !cliente.get_Telefones().Any<ClienteTelefone>())
			{
				str8 = null;
			}
			else
			{
				string numero1 = cliente.get_Telefones().First<ClienteTelefone>().get_Numero();
				if (numero1 != null)
				{
					str8 = numero1.Trim();
				}
				else
				{
					str8 = null;
				}
			}
			fornecedor4.set_Telefone1(str8);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor5 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || !cliente.get_Telefones().Any<ClienteTelefone>() || cliente.get_Telefones().Count <= 2)
			{
				nullable = null;
				tipo1 = nullable;
			}
			else
			{
				tipo1 = cliente.get_Telefones()[1].get_Tipo();
			}
			selectedFornecedor5.set_TipoTelefone2(tipo1);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor5 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || cliente.get_Telefones().Count <= 2)
			{
				str9 = null;
			}
			else
			{
				string prefixo1 = cliente.get_Telefones()[1].get_Prefixo();
				if (prefixo1 != null)
				{
					str9 = prefixo1.Trim();
				}
				else
				{
					str9 = null;
				}
			}
			fornecedor5.set_Prefixo2(str9);
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor6 = this.SelectedFornecedor;
			if (cliente.get_Telefones() == null || cliente.get_Telefones().Count <= 2)
			{
				str10 = null;
			}
			else
			{
				string numero2 = cliente.get_Telefones()[1].get_Numero();
				if (numero2 != null)
				{
					str10 = numero2.Trim();
				}
				else
				{
					str10 = null;
				}
			}
			selectedFornecedor6.set_Telefone2(str10);
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor6 = this.SelectedFornecedor;
			if (cliente.get_Emails() == null || !cliente.get_Emails().Any<ClienteEmail>() || cliente.get_Emails().Count <= 0)
			{
				str11 = null;
			}
			else
			{
				string email = cliente.get_Emails().First<ClienteEmail>().get_Email();
				if (email != null)
				{
					str11 = email.Trim();
				}
				else
				{
					str11 = null;
				}
			}
			fornecedor6.set_Email(str11);
			base.OnPropertyChanged("SelectedFornecedor");
		}

		public async Task Delete()
		{
			if (this.SelectedFornecedor != null && this.SelectedFornecedor.get_Id() != 0)
			{
				if (await base.ShowMessage(string.Concat("DESEJA REALMENTE EXCLUIR O FORNECEDOR ", this.SelectedFornecedor.get_Nome(), "?"), "SIM", "NÃO", false))
				{
					base.Loading(true);
					if (await (new FinanceiroServico()).TemLancamentosPorFornecedor(this.SelectedFornecedor.get_Id()))
					{
						await base.ShowMessage("IMPOSSÍVEL REAIZAR A EXCLUSÃO POIS EXISTEM LANCAMENTOS PARA ESSE FORNECEDOR. PROCESSO INTERROMPIDO", "OK", "", false);
						base.Loading(false);
					}
					else if (await this._servico.Delete(this.SelectedFornecedor))
					{
						await this.SelecionaFornecedor();
						this.SelectedFornecedor = this.FornecedorFiltrados.FirstOrDefault<Gestor.Model.Domain.Financeiro.Fornecedor>();
						base.ToggleSnackBar("FORNECEDOR EXCLUÍDO COM SUCESSO", true);
						base.Loading(false);
					}
					else
					{
						base.Loading(false);
					}
				}
			}
		}

		public async void Excel()
		{
			XLWorkbook xLWorkbook = new XLWorkbook();
			string str = "RELAÓRIO DE FORNECEDOR";
			xLWorkbook = await Funcoes.GerarXls<Gestor.Model.Domain.Financeiro.Fornecedor>(xLWorkbook, str, this.FornecedorFiltrados.ToList<Gestor.Model.Domain.Financeiro.Fornecedor>(), null);
			string tempPath = "";
			string 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
					{
						str = null;
						return;
					}
				}
				string[] strArrays = new string[] { tempPath, str, " ", null, null };
				DateTime date = Functions.GetNetworkTime().Date;
				strArrays[3] = date.ToShortDateString().Replace("/", "");
				strArrays[4] = ".xlsx";
				str1 = string.Concat(strArrays);
			}
			xLWorkbook.SaveAs(str1);
			Process.Start(str1);
			str = null;
		}

		internal async Task<List<Gestor.Model.Domain.Financeiro.Fornecedor>> Filtrar(string value)
		{
			List<Gestor.Model.Domain.Financeiro.Fornecedor> fornecedors = await Task.Run<List<Gestor.Model.Domain.Financeiro.Fornecedor>>(() => this.FiltrarFornecedor(value));
			return fornecedors;
		}

		public List<Gestor.Model.Domain.Financeiro.Fornecedor> FiltrarFornecedor(string filter)
		{
			this.FornecedorFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor>(this.Fornecedor) : new ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor>(this.Fornecedor.Where<Gestor.Model.Domain.Financeiro.Fornecedor>((Gestor.Model.Domain.Financeiro.Fornecedor x) => {
				if (Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Nome().Trim()).ToUpper().Contains(Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(filter)) || x.get_Documento() != null && Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Documento().Trim()).Contains(filter) || x.get_Telefone1() != null && Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Telefone1().Trim()).Contains(filter) || x.get_Telefone2() != null && Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Telefone2().Trim()).Contains(filter))
				{
					return true;
				}
				if (x.get_Email() == null)
				{
					return false;
				}
				return Gestor.Common.Validation.ValidationHelper.RemoveDiacritics(x.get_Email().Trim()).Contains(filter);
			}).OrderByDescending<Gestor.Model.Domain.Financeiro.Fornecedor, string>((Gestor.Model.Domain.Financeiro.Fornecedor x) => x.get_Nome())));
			if (this.FornecedorFiltrados.Count == 1)
			{
				this.SelectedFornecedor = this.FornecedorFiltrados.First<Gestor.Model.Domain.Financeiro.Fornecedor>();
			}
			return this.FornecedorFiltrados.ToList<Gestor.Model.Domain.Financeiro.Fornecedor>();
		}

		public async void Imprimir()
		{
			await base.ImprimirFornecedor(this.FornecedorFiltrados.ToList<Gestor.Model.Domain.Financeiro.Fornecedor>());
		}

		public void Incluir()
		{
			long id;
			Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor = this.SelectedFornecedor;
			if (selectedFornecedor != null)
			{
				id = selectedFornecedor.get_Id();
			}
			else
			{
				id = (long)0;
			}
			this._ultimoId = id;
			Gestor.Model.Domain.Financeiro.Fornecedor fornecedor = new Gestor.Model.Domain.Financeiro.Fornecedor();
			fornecedor.set_IdEmpresa((long)1);
			fornecedor.set_Ativo(true);
			this.SelectedFornecedor = fornecedor;
			base.Alterar(true);
		}

		public async Task<List<KeyValuePair<string, string>>> Salvar()
		{
			List<KeyValuePair<string, string>> keyValuePairs;
			List<KeyValuePair<string, string>> keyValuePairs1 = this.SelectedFornecedor.Validate();
			List<KeyValuePair<string, string>> keyValuePairs2 = keyValuePairs1;
			keyValuePairs2.AddRange(await this.Validate());
			keyValuePairs2 = null;
			if (keyValuePairs1.Count <= 0)
			{
				if (!this.SelectedFornecedor.get_TipoPagamento().HasValue)
				{
					this.SelectedFornecedor.set_TipoPagamento(new TipoPagamento?(12));
				}
				if (!string.IsNullOrWhiteSpace(this.Anotacoes))
				{
					Gestor.Model.Domain.Financeiro.Fornecedor selectedFornecedor = this.SelectedFornecedor;
					object[] nome = new object[] { Recursos.Usuario.get_Nome(), Recursos.Usuario.get_Id(), Funcoes.GetNetworkTime(), Environment.NewLine, this.Anotacoes, Environment.NewLine, Environment.NewLine, this.SelectedFornecedor.get_Observacao() };
					selectedFornecedor.set_Observacao(string.Format("{0}, ID: {1}, {2:g}{3}{4}{5}{6}{7}", nome));
				}
				Gestor.Model.Domain.Financeiro.Fornecedor fornecedor = await this._servico.Save(this.SelectedFornecedor);
				if (this._servico.Sucesso)
				{
					await this.SelecionaFornecedor();
					this.SelectedFornecedor = this.FornecedorFiltrados.First<Gestor.Model.Domain.Financeiro.Fornecedor>((Gestor.Model.Domain.Financeiro.Fornecedor x) => x.get_Id() == fornecedor.get_Id());
					base.ToggleSnackBar("FORNECEDOR SALVO COM SUCESSO", true);
					base.Alterar(false);
					keyValuePairs = null;
				}
				else
				{
					keyValuePairs = null;
				}
			}
			else
			{
				keyValuePairs = keyValuePairs1;
			}
			keyValuePairs1 = null;
			return keyValuePairs;
		}

		private async Task SelecionaFornecedor()
		{
			this.Fornecedor = await this._servico.BuscarFornecedores();
			FornecedorViewModel observableCollection = this;
			List<Gestor.Model.Domain.Financeiro.Fornecedor> fornecedor = this.Fornecedor;
			observableCollection.FornecedorFiltrados = new ObservableCollection<Gestor.Model.Domain.Financeiro.Fornecedor>(
				from x in fornecedor
				orderby x.get_Nome()
				select x);
		}

		public async Task<List<KeyValuePair<string, string>>> Validate()
		{
			List<KeyValuePair<string, string>> keyValuePairs = Gestor.Model.Helper.ValidationHelper.AddValue();
			if (!string.IsNullOrWhiteSpace(this.SelectedFornecedor.get_Documento()))
			{
				List<Gestor.Model.Domain.Financeiro.Fornecedor> list = await this._servico.BuscarFornecedores();
				list = list.Where<Gestor.Model.Domain.Financeiro.Fornecedor>((Gestor.Model.Domain.Financeiro.Fornecedor x) => {
					if (x.get_Id() == this.SelectedFornecedor.get_Id())
					{
						return false;
					}
					return Gestor.Model.Helper.ValidationHelper.DocumentoFornecedor(x.get_Documento()) == Gestor.Model.Helper.ValidationHelper.DocumentoFornecedor(this.SelectedFornecedor.get_Documento());
				}).ToList<Gestor.Model.Domain.Financeiro.Fornecedor>();
				if (list.Count > 0)
				{
					List<KeyValuePair<string, string>> keyValuePairs1 = keyValuePairs;
					List<Gestor.Model.Domain.Financeiro.Fornecedor> fornecedors = list;
					Gestor.Model.Helper.ValidationHelper.AddValue<string, string>(keyValuePairs1, "DOCUMENTO", string.Concat("DOCUMENTO JÁ CADASTRADO PARA OUTROS FORNECEDORES ", string.Join(" | ", 
						from x in fornecedors
						select x.get_Nome())), true);
				}
			}
			List<KeyValuePair<string, string>> keyValuePairs2 = keyValuePairs;
			keyValuePairs = null;
			return keyValuePairs2;
		}
	}
}