decompiler.com

1 files changed, 259 insertions, 0 deletions

diff --git a/Decompiler/Gestor.Application.ViewModels/TrilhaViewModel.cs b/Decompiler/Gestor.Application.ViewModels/TrilhaViewModel.cs
new file mode 100644
index 0000000..2c6d1d6
--- /dev/null
+++ b/Decompiler/Gestor.Application.ViewModels/TrilhaViewModel.cs
@@ -0,0 +1,259 @@
+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);
+	}
+}