Esempio n. 1
0
        private void removerFato_btn_Click(object sender, EventArgs e)
        {
            if (fatosCriados_listbox.SelectedItem == null)
            {
                return;
            }

            var nome = fatosCriados_listbox.SelectedItem as string;

            var msgBox = new CustomMsgBox("Remover Fato", $"Você tem certeza de que deseja remover o fato {nome}?", MessageBoxType.E_SimNao);
            var result = msgBox.ShowDialog();

            if (result == DialogResult.OK)
            {
                var sel = fatosCriados_listbox.SelectedIndex;

                var item = Manager.instance.FindFatoByName(nome);

                if (item == null)
                {
                    return;
                }

                ObjetivosAlvo.Remove(item);

                Manager.instance.RemoverFatoItem(item);

                ReUpdateFatoObjetivos();

                AtualizarFatosCriados();
                AtualizarObjetivos();
            }
        }
        private void ok_btn_Click(object sender, EventArgs e)
        {
            if (novaRegra_txtbox.Text == string.Empty)
            {
                var msgBox = new CustomMsgBox("Salvar Regra", "Preencha corretamente os campos para poder salvar!", MessageBoxType.E_OK);
                msgBox.ShowDialog();
            }
            else
            {
                Manager.instance.AdicionarRegra(regra);

                var msgBox = new CustomMsgBox("Regra Criada", $"Regra {novaRegra_txtbox.Text} criada com sucesso!", MessageBoxType.E_OK);
                msgBox.ShowDialog();

                this.Close();
            }
        }
Esempio n. 3
0
        private void removerRegra_btn_Click(object sender, EventArgs e)
        {
            if (regrasCriadas_listbox.SelectedItem == null)
            {
                return;
            }

            var r = regrasCriadas_listbox.SelectedItem as Estruturas.Regra;

            var msgBox = new CustomMsgBox("Remover Regra", $"Você tem certeza de que deseja remover a regra {r.Nome}?", MessageBoxType.E_SimNao);
            var result = msgBox.ShowDialog();

            if (result == DialogResult.OK)
            {
                Manager.instance.RemoverRegra(r);
                AtualizarRegrasCriadas();
            }
        }
Esempio n. 4
0
        private void CriarNovoFato()
        {
            if (!IsValid())
            {
                var msgBox = new CustomMsgBox("Salvar", "Preencha corretamente os campos para poder salvar!", MessageBoxType.E_OK);
                msgBox.ShowDialog();
                return;
            }
            var nome = nomeFato_txtbox.Text;
            var tipo = BuscaTipoRespostaSelecionada();

            Manager.instance.CriarFato(nome, tipo, Respostas.ToArray());

            var success = new CustomMsgBox("Novo Fato", "Fato criado com sucesso!", MessageBoxType.E_OK);

            success.ShowDialog();

            Init();
        }
Esempio n. 5
0
        private void RetornaRespostaParaUsuario(RespostasUsuario respostasUsuario, List <Regra> regrasPossiveis)
        {
            if (regrasPossiveis.Count == 0)
            {
                var noContent = new CustomMsgBox("FIM", "Não existe resultado possível!", MessageBoxType.E_OK);
                noContent.ShowDialog();
                return;
            }

            else if (regrasPossiveis.Count == 1)
            {
                string msg = "";
                foreach (var objetivo in regrasPossiveis.First().condicaoObjetivos)
                {
                    msg += $"{objetivo.Fato.Nome} {Util.ParseOperador(objetivo.Operador)} {objetivo.Resposta.Descricao}\n";
                }
                var msgBox = new CustomMsgBox("Resultado", msg, MessageBoxType.E_OK);
                msgBox.ShowDialog();
                return;
            }

            else
            {
                string msg = "";
                foreach (var regra in regrasPossiveis)
                {
                    foreach (var objetivo in regra.condicaoObjetivos)
                    {
                        msg += $"{objetivo.Fato.Nome} {Util.ParseOperador(objetivo.Operador)} {objetivo.Resposta.Descricao}\n";
                    }
                }

                var msgBox = new CustomMsgBox("Possibilidades", msg, MessageBoxType.E_OK);
                msgBox.ShowDialog();
                return;
            }
        }
Esempio n. 6
0
        private void button3_Click(object sender, EventArgs e)
        {
            var regras = ObterRegrasComObjetivosAlvo().ToList();

            if (regras.Count() == 0)
            {
                var noContent = new CustomMsgBox("Falha na inicialização", "É necessário selecionar pelomenos um objetivo antes de inicializar.", MessageBoxType.E_OK);
                noContent.ShowDialog();
                return;
            }

            var fatos = GetDistinctFatos(regras);

            if (fatos.Count == 0)
            {
                return;
            }

            var respostasUsuario = new RespostasUsuario();

            var regrasPossiveis = new List <Regra>();

            bool boolPrimeiroLoop = true;

            foreach (var fato in fatos)
            {
                using (var perguntas = new Perguntas(fato))
                {
                    perguntas.ShowDialog();

                    var resposta = GetResposta(fato, perguntas);

                    if (boolPrimeiroLoop)
                    {
                        boolPrimeiroLoop = false;
                        foreach (var regra in regras)
                        {
                            if (!regra.Condicao.Any(c => c.Fato.Nome == fato.Nome)) //na regra, nao importa o fato atual, somente outro
                            {
                                regrasPossiveis.Add(regra);
                            }
                            else
                            {
                                foreach (var condicao in regra.Condicao)
                                {
                                    if (fato.Nome == condicao.Fato.Nome)
                                    {
                                        if (VerificaRespostaBaseadoNoTipo(fato.Tipo, condicao.Operador, condicao.Resposta, resposta))
                                        {
                                            regrasPossiveis.Add(regra);
                                            if (regra.Condicao.Count == 1 && regrasPossiveis.Count == 1 && regras.Count == 1)
                                            {
                                                RetornaRespostaParaUsuario(respostasUsuario, regrasPossiveis);
                                                return;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (regrasPossiveis.Count == 0)
                        {
                            RetornaRespostaParaUsuario(respostasUsuario, regrasPossiveis);
                            return;
                        }
                    }
                    else
                    {
                        var copy = new List <Regra>();
                        copy.AddRange(regrasPossiveis);
                        foreach (var regra in copy)
                        {
                            var possuiConectorOu = regra.Condicao.Any(c => c.Conectivo == Conectivo.OU);
                            if (regra.Condicao.Any(c => c.Fato.Nome == fato.Nome))
                            {
                                foreach (var condicao in regra.Condicao)
                                {
                                    if (fato.Nome == condicao.Fato.Nome)
                                    {
                                        if (!VerificaRespostaBaseadoNoTipo(fato.Tipo, condicao.Operador, condicao.Resposta, resposta))
                                        {
                                            regrasPossiveis.Remove(regra);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    respostasUsuario.AdicionaResposta(fato, resposta);
                }
            }

            RetornaRespostaParaUsuario(respostasUsuario, regrasPossiveis);
        }