path: root/Decompiler/Gestor.Application.ViewModels.BI/NotasViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos;
using Gestor.Application.ViewModels.Generic;
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.BI;

public class NotasViewModel : BaseSegurosViewModel
{
	private readonly TarefaServico _servico;

	private bool _enableIncluirNota = true;

	private bool _ocultarUsuarios;

	private ObservableCollection<Usuario> _usuarios;

	private Usuario _selectedUsuario;

	private Tarefa _tarefa;

	private ObservableCollection<Tarefa> _notas;

	private ObservableCollection<Tarefa> _notasConcluidas;

	private Tarefa _selectedNota;

	private bool _ocultarNotasConcluidas = true;

	public bool EnableIncluirNota
	{
		get
		{
			return _enableIncluirNota;
		}
		set
		{
			_enableIncluirNota = value;
			OnPropertyChanged("EnableIncluirNota");
		}
	}

	public bool OcultarUsuarios
	{
		get
		{
			return _ocultarUsuarios;
		}
		set
		{
			_ocultarUsuarios = value;
			OnPropertyChanged("OcultarUsuarios");
		}
	}

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

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

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

	public ObservableCollection<Tarefa> Notas
	{
		get
		{
			return _notas;
		}
		set
		{
			_notas = value;
			OnPropertyChanged("Notas");
		}
	}

	public ObservableCollection<Tarefa> NotasConcluidas
	{
		get
		{
			return _notasConcluidas;
		}
		set
		{
			_notasConcluidas = value;
			OnPropertyChanged("NotasConcluidas");
		}
	}

	public Tarefa SelectedNota
	{
		get
		{
			return _selectedNota;
		}
		set
		{
			_selectedNota = value;
			OnPropertyChanged("SelectedNota");
		}
	}

	public bool OcultarNotasConcluidas
	{
		get
		{
			return _ocultarNotasConcluidas;
		}
		set
		{
			_ocultarNotasConcluidas = value;
			OnPropertyChanged("OcultarNotasConcluidas");
		}
	}

	public NotasViewModel()
	{
		_servico = new TarefaServico();
		Usuarios = new ObservableCollection<Usuario>((from x in Recursos.Usuarios
			where (Recursos.Usuario.IdEmpresa == 1 || x.IdEmpresa == Recursos.Usuario.IdEmpresa) && !x.Excluido
			orderby x.Nome
			select x).ToList());
		SelectedUsuario = ((IEnumerable<Usuario>)Usuarios).FirstOrDefault((Func<Usuario, bool>)((Usuario x) => ((DomainBase)x).Id == ((DomainBase)Recursos.Usuario).Id));
		Usuario usuario = Recursos.Usuario;
		OcultarUsuarios = usuario != null && usuario.Administrador;
		Usuario usuario2 = Recursos.Usuario;
		EnableIncluirNota = usuario2 != null && ((DomainBase)usuario2).Id > 0;
	}

	public async void Carregar()
	{
		await CarregarNotas();
	}

	public async Task CarregarNotas()
	{
		if (SelectedUsuario == null)
		{
			return;
		}
		List<Tarefa> list = await _servico.BuscarNotas(((DomainBase)SelectedUsuario).Id);
		list.ForEach(delegate(Tarefa x)
		{
			if (x.Titulo == "TÍTULO" && x.Descricao == "DESCRIÇÃO")
			{
				x.HabilitarPublica = true;
			}
		});
		Notas = new ObservableCollection<Tarefa>(list);
		NotasConcluidas = new ObservableCollection<Tarefa>(await _servico.BuscarNotasConcluidas(((DomainBase)SelectedUsuario).Id));
	}

	public async Task AdicionarNota()
	{
		if (Notas != null && Notas.Any((Tarefa x) => x.Titulo == "TÍTULO" && x.Descricao == "DESCRIÇÃO"))
		{
			await ShowMessage("PARA ADICIONAR OUTRA NOTA, INSERIR TÍTULO E DESCRIÇÃO DA NOTA JÁ ADICIONADA");
			return;
		}
		Tarefa nota2 = new Tarefa
		{
			Agendamento = Funcoes.GetNetworkTime(),
			Titulo = "TÍTULO",
			Anotacoes = "DESCRIÇÃO",
			Usuario = Usuarios.First((Usuario x) => ((DomainBase)x).Id == ((DomainBase)SelectedUsuario).Id),
			UsuarioCadastro = Recursos.Usuario,
			Entidade = (TipoTarefa)1,
			Status = (StatusTarefa)0
		};
		nota2 = await _servico.Salvar(nota2);
		await CarregarNotas();
		SelectedNota = nota2;
	}

	public async Task<Tarefa> SalvarNota(Tarefa nota)
	{
		return await _servico.Salvar(nota);
	}

	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;
		}
		bool publica = destino.Publica;
		await _servico.Salvar(destino);
		if (!_servico.Sucesso)
		{
			return null;
		}
		if (publica)
		{
			long id = ((DomainBase)destino.Usuario).Id;
			List<Usuario> usuarios = Recursos.Usuarios;
			List<Task> list2 = new List<Task>();
			foreach (Usuario item in usuarios)
			{
				if (id != ((DomainBase)item).Id)
				{
					Tarefa val = (Tarefa)((DomainBase)destino).Clone();
					((DomainBase)val).Id = 0L;
					val.Usuario = item;
					list2.Add(_servico.Salvar(val));
				}
			}
			await Task.WhenAll(list2);
		}
		await CarregarNotas();
		return null;
	}

	public void ToggleNotasConcluidas()
	{
		OcultarNotasConcluidas = !OcultarNotasConcluidas;
	}

	public async Task ExcluirNota(Tarefa nota)
	{
		await _servico.Excluir(((DomainBase)nota).Id);
	}
}