path: root/Decompiler/Gestor.Application.ViewModels/TrilhaViewModel.cs

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

namespace Gestor.Application.ViewModels;

public class TrilhaViewModel : BaseSegurosViewModel
{
	private ObservableCollection<Trilha> _trilhas = new ObservableCollection<Trilha>();

	private ObservableCollection<Fase> _fases = new ObservableCollection<Fase>();

	private Trilha _selectedTrilha = new Trilha();

	private Tarefa _selectedTarefa;

	private ObservableCollection<Usuario> _usuarios;

	private Usuario _selectedUsuario = new Usuario();

	private TarefaServico Servico { get; }

	public ObservableCollection<Trilha> Trilhas
	{
		get
		{
			return _trilhas;
		}
		set
		{
			_trilhas = value;
			OnPropertyChanged("Trilhas");
		}
	}

	public ObservableCollection<Fase> Fases
	{
		get
		{
			return _fases;
		}
		set
		{
			_fases = value;
			OnPropertyChanged("Fases");
		}
	}

	public Trilha SelectedTrilha
	{
		get
		{
			return _selectedTrilha;
		}
		set
		{
			_selectedTrilha = value;
			OnPropertyChanged("SelectedTrilha");
		}
	}

	public Tarefa SelectedTarefa
	{
		get
		{
			return _selectedTarefa;
		}
		set
		{
			_selectedTarefa = value;
			OnPropertyChanged("SelectedTarefa");
		}
	}

	public ObservableCollection<Usuario> Usuarios
	{
		get
		{
			return _usuarios;
		}
		set
		{
			_usuarios = value;
			OnPropertyChanged("Usuarios");
		}
	}

	public Usuario SelectedUsuario
	{
		get
		{
			return _selectedUsuario;
		}
		set
		{
			_selectedUsuario = value;
			OnPropertyChanged("SelectedUsuario");
		}
	}

	public TrilhaViewModel()
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Expected O, but got Unknown
		Servico = new TarefaServico();
		List<Usuario> list = new List<Usuario>
		{
			new Usuario
			{
				Id = 0L,
				Nome = "TODOS OS USUÁRIOS"
			}
		};
		list.AddRange((from x in Recursos.Usuarios
			where (Recursos.Usuario.IdEmpresa == 1 || x.IdEmpresa == Recursos.Usuario.IdEmpresa) && !x.Excluido
			orderby x.Nome
			select x).ToList());
		Usuarios = new ObservableCollection<Usuario>(list);
		SelectedUsuario = Usuarios.First();
		Gestor.Application.Actions.Actions.AtualizaTrilhas = (Action)Delegate.Combine(Gestor.Application.Actions.Actions.AtualizaTrilhas, new Action(AtualizarTrilhas));
		CarregaTrilhas();
	}

	public void AtualizarTrilhas()
	{
		CarregaTrilhas();
	}

	public async void CarregaTrilhas()
	{
		await CarregarTrilhas();
	}

	public async Task CarregarTrilhas(Trilha trilha = null)
	{
		List<Trilha> list = await Servico.BuscarTrilhas();
		Trilhas = new ObservableCollection<Trilha>(list);
		await CarregarTrilha((trilha != null) ? ((IEnumerable<Trilha>)Trilhas).FirstOrDefault((Func<Trilha, bool>)((Trilha x) => ((DomainBase)x).Id == ((DomainBase)trilha).Id)) : list.FirstOrDefault());
	}

	public async Task CarregarTrilha(Trilha trilha)
	{
		if (trilha == null || ((DomainBase)trilha).Id == 0L)
		{
			return;
		}
		SelectedTrilha = trilha;
		List<Tarefa> tarefas = await Servico.BuscarTarefas(((DomainBase)trilha).Id);
		List<Fase> obj = await Servico.BuscarFases(((DomainBase)trilha).Id);
		Fases = new ObservableCollection<Fase>();
		obj.ForEach(delegate(Fase x)
		{
			x.Tarefas = tarefas.Where((Tarefa t) => (SelectedUsuario == null || ((DomainBase)SelectedUsuario).Id == 0L || ((DomainBase)SelectedUsuario).Id == ((DomainBase)t.Usuario).Id) && ((DomainBase)t.Fase).Id == ((DomainBase)x).Id && (int)t.Status != 2).ToList();
			Fases.Add(x);
		});
	}

	public void Excluir(Fase origem, Tarefa data)
	{
		Tarefa item = Fases.First((Fase x) => ((DomainBase)x).Id == ((DomainBase)origem).Id).Tarefas.First((Tarefa x) => ((DomainBase)x).Id == ((DomainBase)data).Id);
		Fases.First((Fase x) => ((DomainBase)x).Id == ((DomainBase)origem).Id).Tarefas.Remove(item);
	}

	public async Task Excluir(Tarefa tarefa)
	{
		if (((DomainBase)tarefa).Id != 0L && await ShowMessage("DESEJA REALMENTE EXCLUIR A TAREFA " + tarefa.Titulo + "?" + Environment.NewLine + "ESSE PROCEDIMENTO É IRREVERSÍVEL", "SIM", "NÃO"))
		{
			if (!(await Servico.Excluir(((DomainBase)tarefa).Id)))
			{
				Alterar(alterar: false);
				return;
			}
			await CarregarTrilha(SelectedTrilha);
			Alterar(alterar: false);
		}
	}

	public void Inserir(Fase origem, Tarefa data, int index, bool aberto = false)
	{
		data.Aberto = aberto;
		data.Fase = origem;
		Fases.First((Fase x) => ((DomainBase)x).Id == ((DomainBase)origem).Id).Tarefas.Insert((index != -1) ? index : 0, data);
		TrocarFase(data);
	}

	public void Update()
	{
		Fases = new ObservableCollection<Fase>(Fases);
	}

	public async Task<List<KeyValuePair<string, string>>> Salvar(Tarefa destino)
	{
		destino.AgendamentoRetroativo = Recursos.Configuracoes.Any((ConfiguracaoSistema x) => (int)x.Configuracao == 45);
		List<KeyValuePair<string, string>> list = destino.Validate();
		if (list.Count > 0)
		{
			return list;
		}
		await Servico.Salvar(destino);
		if (!Servico.Sucesso)
		{
			return null;
		}
		await CarregarTrilha(SelectedTrilha);
		return null;
	}

	public async Task Salvar(Trilha destino)
	{
		SelectedTrilha = null;
		Fases = null;
		List<Fase> fases = destino.Fases;
		Trilha trilha = await Servico.Salvar(destino);
		if (!Servico.Sucesso)
		{
			return;
		}
		if (fases != null)
		{
			fases.ForEach(delegate(Fase x)
			{
				x.Trilha = trilha;
			});
			await Servico.Salvar(fases);
			if (!Servico.Sucesso)
			{
				return;
			}
		}
		await CarregarTrilhas(trilha);
	}

	public async Task Cancelar()
	{
		await CarregarTrilha(SelectedTrilha);
		Alterar(alterar: false);
	}

	private async void TrocarFase(Tarefa tarefa)
	{
		await Servico.Salvar(tarefa);
	}
}