path: root/Decompiler/Gestor.Application.ViewModels.Drawer/VinculoVendedorViewModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
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.Infrastructure.UnitOfWork.Generic;
using Gestor.Infrastructure.UnitOfWork.Logic;
using Gestor.Model.Common;
using Gestor.Model.Domain.Common;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Seguros;
using Newtonsoft.Json;

namespace Gestor.Application.ViewModels.Drawer;

public class VinculoVendedorViewModel : BaseSegurosViewModel
{
	private readonly VendedorUsuarioServico _servicoVendedorUsuario;

	private readonly VendedorServico _servicoVendedor;

	public readonly Usuario SelectedUsuario;

	private bool _isVisibleVinculado;

	private bool _enableAlterarVinculo;

	private bool _isVisibleVendedor = true;

	private List<VinculoVendedor> _vinculado;

	private List<VinculoVendedor> _vinculadoFiltro;

	private List<VinculoVendedor> _vendedor;

	private List<VinculoVendedor> _vendedorFiltro;

	public bool IsVisibleVinculado
	{
		get
		{
			return _isVisibleVinculado;
		}
		set
		{
			_isVisibleVinculado = value;
			OnPropertyChanged("IsVisibleVinculado");
		}
	}

	public bool EnableAlterarVinculo
	{
		get
		{
			return _enableAlterarVinculo;
		}
		set
		{
			_enableAlterarVinculo = value;
			OnPropertyChanged("EnableAlterarVinculo");
		}
	}

	public bool IsVisibleVendedor
	{
		get
		{
			return _isVisibleVendedor;
		}
		set
		{
			_isVisibleVendedor = value;
			OnPropertyChanged("IsVisibleVendedor");
		}
	}

	public List<VinculoVendedor> Vinculado
	{
		get
		{
			return _vinculado;
		}
		set
		{
			_vinculado = value;
			IsVisibleVinculado = value != null && value.Count > 0;
			OnPropertyChanged("Vinculado");
		}
	}

	public List<VinculoVendedor> VinculadoFiltro
	{
		get
		{
			return _vinculadoFiltro;
		}
		set
		{
			_vinculadoFiltro = value;
			OnPropertyChanged("VinculadoFiltro");
		}
	}

	public List<VinculoVendedor> Vendedor
	{
		get
		{
			return _vendedor;
		}
		set
		{
			_vendedor = value;
			IsVisibleVendedor = value != null && value.Count > 0;
			OnPropertyChanged("Vendedor");
		}
	}

	public List<VinculoVendedor> VendedorFiltro
	{
		get
		{
			return _vendedorFiltro;
		}
		set
		{
			_vendedorFiltro = value;
			OnPropertyChanged("VendedorFiltro");
		}
	}

	public VinculoVendedorViewModel(Usuario usuario)
	{
		SelectedUsuario = usuario;
		_servicoVendedorUsuario = new VendedorUsuarioServico();
		_servicoVendedor = new VendedorServico();
		Load(usuario);
		EnableAlterarVinculo = ((DomainBase)Recursos.Usuario).Id > 0;
		base.EnableMenu = true;
	}

	private async void Load(Usuario usuario)
	{
		await AwaitLoad(usuario);
	}

	private async Task AwaitLoad(Usuario usuario)
	{
		Vinculado = await GetVinculo(usuario);
		Vendedor = await GetVendedor(usuario);
		VinculadoFiltro = Vinculado;
		VendedorFiltro = Vendedor;
	}

	private async Task<List<VinculoVendedor>> GetVinculo(Usuario usuario)
	{
		List<VinculoVendedor> vinculado = new List<VinculoVendedor>();
		(await _servicoVendedorUsuario.FindByVinculo(usuario)).ForEach(delegate(VendedorUsuario x)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			VinculoVendedor item = new VinculoVendedor
			{
				Id = ((DomainBase)x).Id,
				Vendedor = x.Vendedor,
				Vinculado = true
			};
			vinculado.Add(item);
		});
		return vinculado;
	}

	private async Task<List<VinculoVendedor>> GetVendedor(Usuario usuario)
	{
		List<Vendedor> list = (await _servicoVendedor.BuscarVendedoresAtivosAsync())?.Where((Vendedor x) => x.IdEmpresa == usuario.IdEmpresa).ToList();
		return (list == null || list.Count == 0) ? null : list.Where((Vendedor vendedor) => Vinculado.All((VinculoVendedor x) => ((DomainBase)x.Vendedor).Id != ((DomainBase)vendedor).Id)).Select((Func<Vendedor, VinculoVendedor>)((Vendedor vendedor) => new VinculoVendedor
		{
			Id = 0L,
			Vendedor = vendedor,
			Vinculado = false
		})).ToList();
	}

	internal async Task BuscarVinculoVendedor(string value)
	{
		await Task.Run(delegate
		{
			FiltrarVinculoVendedor(value);
		});
	}

	internal void FiltrarVinculoVendedor(string filter)
	{
		Vinculado = (string.IsNullOrEmpty(filter) ? VinculadoFiltro : new List<VinculoVendedor>(VinculadoFiltro.Where((VinculoVendedor x) => ValidationHelper.RemoveDiacritics(x.Vendedor.Nome.ToUpper().Trim()).Contains(filter.ToUpper()))));
		Vendedor = (string.IsNullOrEmpty(filter) ? VendedorFiltro : new List<VinculoVendedor>(VendedorFiltro.Where((VinculoVendedor x) => ValidationHelper.RemoveDiacritics(x.Vendedor.Nome.ToUpper().Trim()).Contains(filter.ToUpper()))));
	}

	public async Task Salvar()
	{
		List<VendedorUsuario> list = Vinculado.Where((VinculoVendedor x) => !x.Vinculado).Select((Func<VinculoVendedor, VendedorUsuario>)((VinculoVendedor x) => new VendedorUsuario
		{
			Id = ((DomainBase)x).Id,
			Vendedor = x.Vendedor,
			Usuario = SelectedUsuario
		})).ToList();
		if (list.Count > 0 && !(await _servicoVendedorUsuario.Delete(list)))
		{
			return;
		}
		List<VendedorUsuario> list2 = Vendedor.Where((VinculoVendedor x) => x.Vinculado).Select((Func<VinculoVendedor, VendedorUsuario>)((VinculoVendedor x) => new VendedorUsuario
		{
			Id = ((DomainBase)x).Id,
			Vendedor = x.Vendedor,
			Usuario = SelectedUsuario
		})).ToList();
		if (list2.Count > 0)
		{
			await _servicoVendedorUsuario.SaveOrUpdate(list2);
		}
		await AwaitLoad(SelectedUsuario);
		UnitOfWork commited = Instancia.Commited;
		try
		{
			IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
			RegistroLog keyValues = new RegistroLog
			{
				Acao = (TipoAcao)0,
				Usuario = Recursos.Usuario,
				DataHora = Funcoes.GetNetworkTime(),
				Descricao = JsonConvert.SerializeObject((object)Vinculado.Select((VinculoVendedor x) => x.Vendedor).ToList(), new JsonSerializerSettings
				{
					ReferenceLoopHandling = (ReferenceLoopHandling)1
				}),
				EntidadeId = ((DomainBase)SelectedUsuario).Id,
				Tela = (TipoTela)45,
				Versao = LoginViewModel.VersaoAtual,
				NomeMaquina = Environment.MachineName,
				UsuarioMaquina = Environment.UserName,
				Ip = hostEntry.AddressList.FirstOrDefault((IPAddress ip) => ip.AddressFamily == AddressFamily.InterNetwork)?.ToString()
			};
			_servicoVendedorUsuario.SaveLog(keyValues, commited);
			((GenericUnitOfWork)commited).Commit();
		}
		finally
		{
			((IDisposable)commited)?.Dispose();
		}
		RegistrarAcao("ALTEROU VÍNCULOS DE VENDEDOR DO USUÁRIO \"" + SelectedUsuario.Nome + "\"", ((DomainBase)SelectedUsuario).Id, (TipoTela)45, $"ID: {((DomainBase)SelectedUsuario).Id}\n\nACESSE O LOG DE ALTERAÇÕES NA TELA DE VÍNCULO DE VENDEDOR PARA VER EXATAMENTE O QUE FOI ALTERADO.");
	}
}