public ActionResult Cadastrar(ExercicioModel exercicioModel)
        {
            var exercicioDomain = new Exercicio();
            var repositorioGrupamento = new Grupamentos();
            var repositorioExercicio = new Exercicios();

            exercicioDomain.Grupamento = repositorioGrupamento.Obter(int.Parse(exercicioModel.Grupamento));
            exercicioDomain.Link = new Link();
            exercicioDomain.Nome = exercicioModel.Nome;
            exercicioDomain.Link.Url = "Http://" + exercicioModel.Url;
            exercicioDomain.Link.Titulo = exercicioModel.Titulo;

            repositorioExercicio.Salvar(exercicioDomain);

            return View("Index");
        }
        public void Inserir_Um_Exercicio()
        {
            for (int i = 0; i < 5; i++)
            {
                var link = new Link
                {
                    Titulo = "Tricipes destro" + i,
                    Url = "www.musculaçaodoida.com"
                };
                var grupamento = new Grupamento
                {
                    Nome = "Braço" + i,
                };
                var exercicio = new Exercicio
                {
                    Nome = "Squat" + i,
                    Link = link
                };
                var repositorio = new Exercicios();
                repositorio.Salvar(exercicio);

            }
        }
    public List <Exercicio> Select()
    {
        List <Exercicio> exercicios = new List <Exercicio>();

        conexao = new SqlConnection(strCon);
        string     sql = "Select * from Exercicio";
        SqlCommand cmd = new SqlCommand(sql, conexao);

        try
        {
            conexao.Open();

            SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            while (reader.Read())
            {
                Exercicio exercicio = new Exercicio();
                exercicio.idExercicio = Convert.ToInt32(reader[0].ToString());
                exercicio.nome        = reader["nome"].ToString();
                exercicio.tipo        = reader["tipo"].ToString();
                exercicio.repeticoes  = reader["repeticoes"].ToString();
                exercicio.observacao  = reader["observacoes"].ToString();

                exercicios.Add(exercicio);
            }
        }
        catch (SqlException ex)
        {
            Console.WriteLine("Deu Erro no Select do ExercicioDal" + ex.ToString());
        }
        finally
        {
            conexao.Close();
        }


        return(exercicios);
    }
Example #4
0
        private async void button3_Click(object sender, EventArgs e)
        {
            try
            {
                if (cboExercicios.Text != "")
                {
                    LimparTudo();
                    int       Tempo  = Convert.ToInt32(txtTempo.Text);
                    int       nroExe = Convert.ToInt32(cboExercicios.Text.Split(' ')[2]);
                    Exercicio Exer   = exerc.exercicio.FirstOrDefault(r => r.e_numero == nroExe);
                    foreach (EPosico pos in Exer.e_posicoes)
                    {
                        foreach (int epos in pos.c_posicao)
                        {
                            string nm_nota = "lbl_" + pos.e_corda + "_" + epos.ToString() + "_";
                            foreach (System.Windows.Forms.Control Notas in BRACO.Controls)
                            {
                                if (Notas is Label)
                                {
                                    Label btnNota = Notas as Label;
                                    if (btnNota.Name.Contains(nm_nota))
                                    {
                                        await doExercicio(btnNota, Tempo);

                                        //
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
    public static void DeleteExercise()
    {
        int IdExercicio = GlobalController.instance.exercise.idExercicio;

        List <PontosRotuloPaciente> allPrps = PontosRotuloPaciente.Read();


        foreach (var prp in allPrps)
        {
            if (prp.idExercicio == IdExercicio)
            {
                PontosRotuloPaciente.DeleteValue(prp.idRotuloPaciente);
            }
        }

        string pathEx = string.Format("{0}/Exercicios/{1}", Application.dataPath, GlobalController.instance.exercise.pontosExercicio);

        if (File.Exists(pathEx))
        {
            File.Delete(pathEx);
        }

        Exercicio.DeleteValue(IdExercicio);
    }
Example #6
0
        public Nota Corrigir(Exercicio Realizado, Exercicio Gabarito)
        {
            decimal TotalQuestoes = Gabarito.Questao.Count;
            decimal acerto        = 0;

            if (Gabarito.Tipo == "C")
            {
                foreach (var itemGabaritoQ in Gabarito.Questao)
                {
                    foreach (var itemRealizadoQ in Realizado.Questao)
                    {
                        if (itemGabaritoQ.Ordem == itemRealizadoQ.Ordem)
                        {
                            foreach (var itemGabaritoA in itemGabaritoQ.Alternativa)
                            {
                                foreach (var itemRealizadoA in itemRealizadoQ.Alternativa)
                                {
                                    if (itemRealizadoA.Conteudo == itemGabaritoA.Conteudo)
                                    {
                                        acerto += 1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                foreach (var itemGabaritoQ in Gabarito.Questao)
                {
                    foreach (var itemRealizadoQ in Realizado.Questao)
                    {
                        if (itemGabaritoQ.Ordem == itemRealizadoQ.Ordem)
                        {
                            foreach (var itemGabaritoA in itemGabaritoQ.Alternativa)
                            {
                                foreach (var itemRealizadoA in itemRealizadoQ.Alternativa)
                                {
                                    if (itemRealizadoA.Ordem == itemGabaritoA.Ordem)
                                    {
                                        if (itemRealizadoA.Tipo == "R")
                                        {
                                            if (itemGabaritoA.Tipo == "C")
                                            {
                                                if (itemRealizadoA.Conteudo == itemGabaritoA.Conteudo)
                                                {
                                                    acerto += 1;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            decimal pontoquestao = 10 / TotalQuestoes;
            decimal nota         = pontoquestao * acerto;
            Nota    n            = new Nota
            {
                _Nota     = nota,
                Exercicio = Realizado
            };
            Usuario    u   = new Usuario();
            UsuarioDAL dal = new UsuarioDAL();

            u         = dal.Consultar(Realizado.Usuario);
            n.Usuario = u;
            return(n);
        }
 public void Apagar(Exercicio exercicio)
 {
     base.Delete(exercicio);
 }
Example #8
0
        public int SetFinalizaSimulado(Exercicio exerc)
        {
            bool finalizarOnlinePorTempo = true;

            return(new ExercicioBusiness(new ExercicioEntity(), new RankingSimuladoEntity(), new SimuladoEntity(), new CartaoRespostaEntity(), new QuestaoEntity(), new AulaEntity()).SetFinalizaExercicio(exerc, finalizarOnlinePorTempo));
        }
Example #9
0
    private void addTotalClicadasErradasPorExercicio()
    {
        Exercicio exercicio = getExercicioAtual();

        exercicio.addTotalClicadasErradas();
    }
Example #10
0
        public async Task <IActionResult> Create(ExercicioViewModel evm)
        {
            using (await dbContext.Database.BeginTransactionAsync())
            {
                try
                {
                    if (ModelState.IsValid)
                    {
                        evm.Descricao = evm.Descricao.Trim();

                        Exercicio e = await dbContext.Exercicios.Where(ex => ex.Descricao == evm.Descricao &&
                                                                       ex.Ativo == true).SingleOrDefaultAsync();

                        if (e == null)
                        {
                            e           = new Exercicio();
                            e.Descricao = evm.Descricao;
                            e.CodVideo  = evm.CodVideo;
                            e.Resposta  = evm.Resposta;
                            e.Ativo     = true;
                            dbContext.Exercicios.Add(e);

                            await dbContext.SaveChangesAsync();


                            Alternativa a1 = new Alternativa();
                            a1.Descricao      = evm.Alternativa1;
                            a1.CodAlternativa = 1;
                            a1.CodExercicio   = e.CodExercicio;
                            a1.Ativo          = true;
                            dbContext.Alternativas.Add(a1);

                            Alternativa a2 = new Alternativa();
                            a2.Descricao      = evm.Alternativa2;
                            a2.CodAlternativa = 2;
                            a2.CodExercicio   = e.CodExercicio;
                            a2.Ativo          = true;
                            dbContext.Alternativas.Add(a2);

                            Alternativa a3 = new Alternativa();
                            a3.Descricao      = evm.Alternativa3;
                            a3.CodAlternativa = 3;
                            a3.CodExercicio   = e.CodExercicio;
                            a3.Ativo          = true;
                            dbContext.Alternativas.Add(a3);

                            Alternativa a4 = new Alternativa();
                            a4.Descricao      = evm.Alternativa4;
                            a4.CodAlternativa = 4;
                            a4.CodExercicio   = e.CodExercicio;
                            a4.Ativo          = true;
                            dbContext.Alternativas.Add(a4);


                            await dbContext.SaveChangesAsync();

                            if (dbContext.Database.CurrentTransaction != null)
                            {
                                dbContext.Database.CommitTransaction();
                            }
                            TempData["Mensagem"] = "Exercício cadastrado com sucesso!";
                            TempData["Sucesso"]  = true;
                            return(RedirectToAction("Index"));
                        }
                        else
                        {
                            TempData["Mensagem"] = "Já existe exercício com essa descrição!";
                        }
                    }

                    evm.Videos = VideoController.GetVideos(dbContext);
                }
                catch (Exception ex)
                {
                    TempData["Mensagem"]  = "Erro ao cadastrar exercício!";
                    TempData["Exception"] = ex;
                    TempData["Sucesso"]   = false;
                    if (dbContext.Database.CurrentTransaction != null)
                    {
                        dbContext.Database.RollbackTransaction();
                    }
                    return(RedirectToAction("Index"));
                }
            }

            return(View(evm));
        }
Example #11
0
        public async Task <IActionResult> Edit(int?id, ExercicioViewModel evm)
        {
            using (await dbContext.Database.BeginTransactionAsync())
            {
                try
                {
                    Exercicio ex = await dbContext.Exercicios.Where(e => e.CodExercicio == id.Value &&
                                                                    e.Ativo == true).SingleOrDefaultAsync();

                    if (ex == null)
                    {
                        return(NotFound());
                    }

                    if (ModelState.IsValid)
                    {
                        ex.Descricao = evm.Descricao.Trim();

                        Exercicio existExercicio = await dbContext.Exercicios.Where(e => e.Descricao == ex.Descricao &&
                                                                                    e.CodExercicio != id.Value && e.Ativo == true).SingleOrDefaultAsync();

                        if (existExercicio == null)
                        {
                            ex.CodVideo = evm.CodVideo;
                            ex.Resposta = evm.Resposta;
                            dbContext.Exercicios.Update(ex);

                            Alternativa a1 = await dbContext.Alternativas.Where(a => a.CodExercicio
                                                                                == ex.CodExercicio && a.CodAlternativa == 1 && a.Ativo == true)
                                             .SingleOrDefaultAsync();

                            a1.Descricao = evm.Alternativa1;
                            dbContext.Alternativas.Update(a1);

                            Alternativa a2 = await dbContext.Alternativas.Where(a => a.CodExercicio
                                                                                == ex.CodExercicio && a.CodAlternativa == 2 && a.Ativo == true)
                                             .SingleOrDefaultAsync();

                            a2.Descricao = evm.Alternativa2;
                            dbContext.Alternativas.Update(a2);

                            Alternativa a3 = await dbContext.Alternativas.Where(a => a.CodExercicio
                                                                                == ex.CodExercicio && a.CodAlternativa == 3 && a.Ativo == true)
                                             .SingleOrDefaultAsync();

                            a3.Descricao = evm.Alternativa3;
                            dbContext.Alternativas.Update(a3);

                            Alternativa a4 = await dbContext.Alternativas.Where(a => a.CodExercicio
                                                                                == ex.CodExercicio && a.CodAlternativa == 4 && a.Ativo == true)
                                             .SingleOrDefaultAsync();

                            a4.Descricao = evm.Alternativa4;
                            dbContext.Alternativas.Update(a4);


                            await dbContext.SaveChangesAsync();

                            if (dbContext.Database.CurrentTransaction != null)
                            {
                                dbContext.Database.CommitTransaction();
                            }
                            TempData["Mensagem"] = "Exercício alterado com sucesso!";
                            TempData["Sucesso"]  = true;
                            return(RedirectToAction("Index"));
                        }
                        else
                        {
                            TempData["Mensagem"] = "Já existe exercício com essa descrição!";
                        }
                    }

                    evm.CodExercicio = ex.CodExercicio;
                    evm.CodVideo     = ex.CodVideo;
                    evm.Videos       = VideoController.GetVideos(dbContext);
                    evm.DescVideo    = evm.Videos.Where(v => v.CodVideo == evm.CodVideo)
                                       .SingleOrDefault().Descricao;
                }
                catch (Exception ex)
                {
                    TempData["Mensagem"]  = "Erro ao alterar exercício!";
                    TempData["Exception"] = ex;
                    TempData["Sucesso"]   = false;
                    if (dbContext.Database.CurrentTransaction != null)
                    {
                        dbContext.Database.RollbackTransaction();
                    }
                    return(RedirectToAction("Index"));
                }
            }

            return(View(evm));
        }
Example #12
0
    public static void DeletePhysiotherapist()
    {
        int IdFisioterapeuta = GlobalController.instance.admin.idFisioterapeuta;
        int IdPessoa         = GlobalController.instance.admin.persona.idPessoa;

        string nomePessoa = (GlobalController.instance.admin.persona.nomePessoa).Replace(' ', '_');
        string nomePasta  = string.Format("{0}/Movimentos/{1}-{2}", Application.dataPath, IdPessoa, nomePessoa);

        List <Movimento> allMovements            = Movimento.Read();
        List <Sessao>    allSessions             = Sessao.Read();
        List <PontosRotuloFisioterapeuta> allPRF = PontosRotuloFisioterapeuta.Read();
        List <Exercicio>        allExercises     = Exercicio.Read();
        List <MovimentoMusculo> allMovMuscles    = MovimentoMusculo.Read();

        foreach (var movements in allMovements)
        {
            if (movements.idFisioterapeuta == IdFisioterapeuta)
            {
                foreach (var prf in allPRF)
                {
                    if (prf.idMovimento == movements.idMovimento)
                    {
                        PontosRotuloFisioterapeuta.DeleteValue(prf.idRotuloFisioterapeuta);
                    }
                }

                foreach (var mvm in allMovMuscles)
                {
                    if (mvm.idMovimento == movements.idMovimento)
                    {
                        MovimentoMusculo.DeleteValue(mvm.idMovimento, mvm.idMusculo);
                    }
                }

                foreach (var execises in allExercises)
                {
                    if (execises.idMovimento == movements.idMovimento)
                    {
                        Exercicio.DeleteValue(execises.idExercicio);
                    }
                }

                Movimento.DeleteValue(movements.idMovimento);
            }
        }

        foreach (var session in allSessions)
        {
            if (session.idPaciente == IdFisioterapeuta)
            {
                Sessao.DeleteValue(session.idSessao);
            }
        }

        Fisioterapeuta.DeleteValue(IdFisioterapeuta);

        if (Directory.Exists(nomePasta))
        {
            Directory.Delete(nomePasta, true);
        }

        Flow.StaticNewPhysiotherapist();
    }
Example #13
0
 public void Post([FromBody] Exercicio exercicio)
 {
     business.Incluir(exercicio);
 }
Example #14
0
 public IActionResult Put(int id, [FromBody] Exercicio exercicio)
 {
     business.Alterar(exercicio);
     return(NoContent());
 }
        public static IEnumerator TestDeletePatient()
        {
            Flow.StaticLogin();
            Flow.StaticNewPatient();

            yield return(null);

            var objectPatient  = GameObject.Find("Patient Manager");
            var PatientManager = objectPatient.GetComponentInChildren <createPatient>();

            InputField aux = (InputField)PatientManager.GetMemberValue("namePatient");

            aux.text = "Fake Name";
            PatientManager.SetMemberValue("namePatient", aux);

            Text aux1 = (Text)PatientManager.GetMemberValue("outDate");

            aux1.text = "01/01/1920";
            PatientManager.SetMemberValue("outDate", aux1);

            InputField aux3 = (InputField)PatientManager.GetMemberValue("phone1");

            aux3.text = "61999999";
            PatientManager.SetMemberValue("phone1", aux3);

            InputField aux8 = (InputField)PatientManager.GetMemberValue("notes");

            aux8.text = "lorem ipsum";
            PatientManager.SetMemberValue("notes", aux8);

            Toggle aux2 = (Toggle)PatientManager.GetMemberValue("male");

            aux2.isOn = true;
            PatientManager.SetMemberValue("male", aux2);

            Toggle aux0 = (Toggle)PatientManager.GetMemberValue("female");

            aux0.isOn = false;
            PatientManager.SetMemberValue("female", aux0);

            PatientManager.savePatient();

            int IdPaciente = GlobalController.instance.user.idPaciente;
            int IdPessoa   = GlobalController.instance.user.persona.idPessoa;

            yield return(new WaitForSeconds(0.5f));

            DeletePatientButton.DeletePatient();

            yield return(new WaitForSeconds(0.5f));

            var currentscene  = SceneManager.GetActiveScene().name;
            var expectedscene = "NewPatient";

            Assert.AreEqual(expectedscene, currentscene);

            var patients = Paciente.Read();

            foreach (var patient in patients)
            {
                Assert.AreNotEqual(patient.idPaciente, IdPaciente);
            }

            var exers = Exercicio.Read();

            foreach (var exer in exers)
            {
                Assert.AreNotEqual(exer.idPaciente, IdPaciente);
            }

            var sess = Sessao.Read();

            foreach (var ses in sess)
            {
                Assert.AreNotEqual(ses.idPaciente, IdPaciente);
            }

            var ppls = Pessoa.Read();

            foreach (var ppl in ppls)
            {
                Assert.AreNotEqual(ppl.idPessoa, IdPessoa);
            }

            string nomePessoa = (GlobalController.instance.user.persona.nomePessoa).Replace(' ', '_');
            string nomePasta  = string.Format("Assets/Exercicios/{1}-{2}", Application.dataPath, IdPessoa, nomePessoa);

            bool dir = System.IO.Directory.Exists(nomePasta);

            Assert.AreEqual(dir, false);
        }
        public static IEnumerator TestDeleteMovement()
        {
            Flow.StaticLogin();

            yield return(new WaitForSeconds(1f));

            Pessoa.Insert("physio name1", "m", "1995-01-01", "6198732711", null);
            Fisioterapeuta.Insert(1, "abracadabra1", "demais1", null, null);

            var fisio = Fisioterapeuta.GetLast();

            GlobalController.instance.admin = fisio;

            Flow.StaticNewMovement();

            yield return(new WaitForSeconds(1f));

            var moveManager = GameObject.Find("/New Movement Manager").GetComponentInChildren <createMovement>();

            InputField aux = (InputField)moveManager.GetMemberValue("nomeMovimento");

            aux.text = "Fake Name";
            moveManager.SetMemberValue("nomeMovimento", aux);

            InputField aux1 = (InputField)moveManager.GetMemberValue("musculos");

            aux1.text = "Deltoide";
            moveManager.SetMemberValue("musculos", aux1);

            InputField aux3 = (InputField)moveManager.GetMemberValue("descricao");

            aux3.text = "Ahaha seloco";
            moveManager.SetMemberValue("descricao", aux3);

            moveManager.saveMovement();

            var   device = @"^(.*?(\bDevice|SDK\b)[^$]*)$";
            Regex rgx1   = new Regex(device, RegexOptions.IgnoreCase);

            LogAssert.Expect(LogType.Error, rgx1);

            yield return(new WaitForSeconds(1f));

            DeleteMovementButton.DeleteMovement();

            yield return(new WaitForSeconds(0.5f));

            int IdMovimento = GlobalController.instance.movement.idMovimento;

            var prfs = PontosRotuloFisioterapeuta.Read();

            foreach (var prf in prfs)
            {
                Assert.AreNotEqual(prf.idMovimento, IdMovimento);
            }

            var exers = Exercicio.Read();

            foreach (var exer in exers)
            {
                Assert.AreNotEqual(exer.idMovimento, IdMovimento);
            }

            var mms = MovimentoMusculo.Read();

            foreach (var mm in mms)
            {
                Assert.AreNotEqual(mm.idMovimento, IdMovimento);
            }

            var movements = Movimento.Read();

            foreach (var movement in movements)
            {
                Assert.AreNotEqual(movement.idMovimento, IdMovimento);
            }

            string pathMov = string.Format("{0}/Movimentos/{1}", Application.dataPath, GlobalController.instance.movement.pontosMovimento);

            bool dir = System.IO.File.Exists(pathMov);

            Assert.AreEqual(dir, false);
        }
 public void Cadastrar(Exercicio exercicio)
 {
     var repositorio = new Exercicios();
        repositorio.Salvar(exercicio);
 }
        public static List <Exercicio> GetSimuladosRealizadosPeloAlunoBy2019CPMED()
        {
            List <Exercicio> exercicios = new List <Exercicio>();

            var exercicio = new Exercicio()
            {
                ID = 0
                , ExercicioName          = "Teste"
                , TipoId                 = 2
                , EstadoID               = 0
                , RegiaoID               = 0
                , Descricao              = "2019 CPMED - Geral 1"
                , Ordem                  = 0
                , Ano                    = 2019
                , Duracao                = 50
                , QtdQuestoes            = 0
                , TempoTolerancia        = 0
                , TipoApostilaId         = 0
                , StatusId               = 0
                , Ativo                  = true
                , EntidadeApostilaID     = 0
                , Acertos                = 0
                , IsPremium              = false
                , IdConcurso             = 0
                , TempoExcedido          = 0
                , Ranqueado              = 0
                , HistoricoId            = 0
                , DataInicio             = 49852255487
                , DataFim                = 49852255489
                , IdTipoRealizacao       = 1
                , Realizado              = 0
                , Online                 = 0
                , DtLiberacaoRanking     = DateTime.Now.Date.AddDays(10)
                , DtUnixLiberacaoRanking = 0
                , Especialidade          =
                    new Especialidade()
                {
                    Id = 0,
                    IdAreaAcademica   = 1,
                    IntEmployeeID     = 96409,
                    Editavel          = true,
                    DataClassificacao = DateTime.Now.Date,
                    Descricao         = "2019 CPMED - Geral 1"
                }
                ,
                Especialidades = new Especialidades()
                {
                    new Especialidade()
                    {
                        Id = 0,
                        IdAreaAcademica   = 1,
                        IntEmployeeID     = 96409,
                        Editavel          = true,
                        DataClassificacao = DateTime.Now.Date,
                        Descricao         = "2019 CPMED - Geral 1"
                    }
                }
                , Atual        = 0
                , BitAndamento = false
            };

            exercicios.Add(exercicio);
            return(exercicios);
        }
Example #19
0
 public static Exercicio BuscarExercicioPorNome(Exercicio e)
 {
     return(ctx.Exercicios.FirstOrDefault
                (x => x.Nome.Equals(e.Nome)));
 }
        public static List <Exercicio> GetSimuladosRealizadosPeloAlunoByFilters2017MED()
        {
            List <Exercicio> exercicios = new List <Exercicio>();

            var exercicio = new Exercicio()
            {
                Ano                = 2017,
                Descricao          = "2017 SIM01 - Geral 1",
                ID                 = 1,
                ExercicioName      = "Teste",
                DataInicio         = 49852255487,
                DataFim            = 49852255489,
                IdTipoRealizacao   = 1,
                Online             = 0,
                Ativo              = true,
                Duracao            = 50,
                DtLiberacaoRanking = new DateTime()
            };

            exercicios.Add(exercicio);

            exercicios.Add(new Exercicio()
            {
                Ano                = 2017,
                Descricao          = "2017 SIM01 - Geral 2",
                ID                 = 2,
                ExercicioName      = "Teste",
                DataInicio         = 49852255487,
                DataFim            = 49852255489,
                IdTipoRealizacao   = 1,
                Online             = 0,
                Ativo              = true,
                Duracao            = 50,
                DtLiberacaoRanking = new DateTime()
            });

            exercicios.Add(exercicio);

            exercicios.Add(exercicio);

            exercicios.Add(new Exercicio()
            {
                Ano                = 2017,
                Descricao          = "2017 SIM01 - Geral 3",
                ID                 = 3,
                ExercicioName      = "Teste",
                DataInicio         = 49852255487,
                DataFim            = 49852255489,
                IdTipoRealizacao   = 1,
                Online             = 0,
                Ativo              = true,
                Duracao            = 50,
                DtLiberacaoRanking = new DateTime()
            });

            exercicios.Add(new Exercicio()
            {
                Ano                = 2017,
                Descricao          = "2017 SIM01 - Geral 4",
                ID                 = 4,
                ExercicioName      = "Teste",
                DataInicio         = 49852255487,
                DataFim            = 49852255489,
                IdTipoRealizacao   = 1,
                Online             = 1,
                Ativo              = true,
                Duracao            = 50,
                DtLiberacaoRanking = new DateTime()
            });

            exercicios.Add(exercicio);

            exercicios.Add(exercicio);
            return(exercicios);
        }
Example #21
0
 private bool ChecaJaneladeTempoRealizacaoDeSimulado(Exercicio sim)
 {
     return(DateTime.Now >= Convert.ToDateTime(Utilidades.UnixTimeStampToDateTime(sim.DataInicio)) &&
            DateTime.Now <= Convert.ToDateTime(Utilidades.UnixTimeStampToDateTime(sim.DataFim)));
 }
Example #22
0
        public async Task <IActionResult> DeleteConfirmed(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            using (await dbContext.Database.BeginTransactionAsync())
            {
                try
                {
                    Exercicio exerc = await dbContext.Exercicios.Where(e => e.CodExercicio == id.Value &&
                                                                       e.Ativo == true).SingleOrDefaultAsync();

                    if (exerc == null)
                    {
                        return(NotFound());
                    }

                    var alternativas = await dbContext.Alternativas.Where(a => a.Ativo == true)
                                       .ToListAsync();

                    if (alternativas.Count == 0)
                    {
                        return(NotFound());
                    }

                    ExercicioModulo exMod = await dbContext.ExerciciosModulo.Where(em => em.CodExercicio
                                                                                   == exerc.CodExercicio && em.Ativo == true).FirstOrDefaultAsync();

                    if (exMod == null)
                    {
                        exerc.Ativo = false;
                        dbContext.Update(exerc);

                        foreach (Alternativa a in alternativas)
                        {
                            a.Ativo = false;
                            dbContext.Update(a);
                        }

                        await dbContext.SaveChangesAsync();

                        if (dbContext.Database.CurrentTransaction != null)
                        {
                            dbContext.Database.CommitTransaction();
                        }
                        TempData["Mensagem"] = "Exercício excluído com sucesso!";
                        TempData["Sucesso"]  = true;
                    }
                    else
                    {
                        TempData["Mensagem"] = "Não foi possível excluir o exercício porque há um módulo que o " +
                                               "está utilizando!";
                        TempData["Sucesso"] = false;
                    }
                }
                catch (Exception ex)
                {
                    TempData["Mensagem"]  = "Erro ao excluir exercício!";
                    TempData["Exception"] = ex;
                    TempData["Sucesso"]   = false;
                    if (dbContext.Database.CurrentTransaction != null)
                    {
                        dbContext.Database.RollbackTransaction();
                    }
                }
            }

            return(RedirectToAction("Index"));
        }
 public int SetFinalizaApostila(Exercicio exerc)
 {
     return(new ExercicioBusiness(new ExercicioEntity(), new RankingSimuladoEntity(), new SimuladoEntity(), new CartaoRespostaEntity(), new QuestaoEntity(), new AulaEntity())
            .SetFinalizaExercicio(exerc));
 }
Example #24
0
 public static List <Tempo> RetornarTempoPorExercicio(Exercicio exercicio)
 {
     return(ctx.Tempos.Where(tempo => tempo.Exercicio.ExercicioId == exercicio.ExercicioId).ToList());
 }
Example #25
0
 public static bool CreateExrecicioScopIsValid(this Exercicio exercicio)
 {
     return(AssertionConcern.IsSatisfiedBy(
                AssertionConcern.AssertNotEmpty(exercicio.DsExercicio, "O campo exercício é Obrigatório!")
                ));
 }
Example #26
0
        /// <summary>
        /// retorna um objeto do tipo Conteudo
        /// Contendo so o ID Da Materia
        /// E um List de  ConteudoTexto (completo) já organizado em ordem crescente
        /// list de resumos vinculado e exercicios completos
        /// </summary>
        /// <param name="id"> parametro inteiro do id do conteudo</param>
        /// <returns></returns>
        public Conteudo Consultar(int id)
        {
            SqlCommand    comm = new SqlCommand("Select * from Conteudo where ID_Conteudo = " + id, Banco.Abrir());
            SqlDataReader dr   = comm.ExecuteReader();
            Conteudo      c    = new Conteudo();

            while (dr.Read())
            {
                Materia m = new Materia();
                m.ID = Convert.ToInt32(dr.GetValue(1));
                c    = new Conteudo
                {
                    ID      = Convert.ToInt32(dr.GetValue(0)),
                    Materia = m,
                    Nome    = dr.GetValue(2).ToString(),
                    Ordem   = Convert.ToInt32(dr.GetValue(4)),
                    Usuario = Convert.ToInt32(dr.GetValue(5))
                };
                if (dr.GetValue(3) != null)
                {
                    c.Imagem = dr.GetValue(3) as byte[];
                }
            }
            dr.Close();
            comm.CommandText = "Select ID_ConteudoTexto,Ordem_ConteudoTexto from ConteudoTexto where ID_Conteudo = " + id + " order by Ordem_ConteudoTexto";
            dr = comm.ExecuteReader();
            List <ConteudoTexto> listacont = new List <ConteudoTexto>();

            while (dr.Read())
            {
                ConteudoTextoDAL dalcontext = new ConteudoTextoDAL();
                ConteudoTexto    ct         = new ConteudoTexto();
                ct = dalcontext.Consultar(Convert.ToInt32(dr.GetValue(0)));
                listacont.Add(ct);
            }
            c.ConteudoTexto = listacont;
            dr.Close();
            comm.CommandText = "Select ID_Resumo from Resumo where ID_Conteudo = " + id;
            dr = comm.ExecuteReader();
            List <Resumo> listaresumo = new List <Resumo>();

            while (dr.Read())
            {
                ResumoDAL dalresu = new ResumoDAL();
                Resumo    r       = new Resumo();
                r = dalresu.Consultar(Convert.ToInt32(dr.GetValue(0)));
                listaresumo.Add(r);
            }
            c.Resumo = listaresumo;
            dr.Close();
            comm.CommandText = "Select ID_Exercicio from Exercicio where ID_Conteudo = " + id;
            dr = comm.ExecuteReader();
            List <Exercicio> listaexrs = new List <Exercicio>();

            while (dr.Read())
            {
                ExercicioDAL dalex = new ExercicioDAL();
                Exercicio    e     = new Exercicio();
                e = dalex.Consultar(Convert.ToInt32(dr.GetValue(0)));
                listaexrs.Add(e);
            }
            c.Exercicio = listaexrs;
            comm.Connection.Close();
            return(c);
        }
Example #27
0
 public static List <Peso> RetornarPesoPorExercicio(Exercicio exercicio)
 {
     return(ctx.Pesos.Where(peso => peso.Exercicio.ExercicioId == exercicio.ExercicioId).ToList());
 }
Example #28
0
 public bool ChecaTempoHabilUsuarioRealizacaoDeSimulado(int matricula, Exercicio simulado)
 {
     return(DateTime.Now > _repository.GetDtInicioUltimaRealizacao(matricula, simulado.ID).AddMinutes(simulado.Duracao) ? false : true);
 }
 public void Salvar(Exercicio exercicio)
 {
     base.Save(exercicio);
 }
Example #30
0
        private void btnExercicioCadastrar_Click(object sender, EventArgs e)
        {
            using (ExercicioNegocio exercicioNegocio = new ExercicioNegocio())
            {
                ValidacaoInterfaces validarInterface = new ValidacaoInterfaces();
                if (validarInterface.validarCampoCadastrar(this.grpExercicio.Controls) == true)
                {
                    return;
                }
                if (validarInterface.validarCampoCadastrar(this.grpDemonstracao.Controls) == true)
                {
                    return;
                }


                if (acaoNaTelaInformada == AcaoNaTela.Inserir)
                {
                    var       bytes            = Encoding.UTF8.GetBytes(txtCadastrarUrlImagem.Text);
                    var       base64           = Convert.ToBase64String(bytes);
                    Exercicio exercicioInserir = new Exercicio()
                    {
                        Nome                  = this.txtCadastrarNome.Text,
                        Descricao             = this.rckCadastrarDescricao.Text,
                        DemonstracaoUrlImagem = txtCadastrarUrlImagem.Text,
                        DemonstracaoUrlVideo  = this.txtCadastrarUrlVideo.Text
                    };

                    exercicioInserir.TipoExercicio = new TipoExercicio()
                    {
                        IDTipoExercicio = Convert.ToInt32(cmbCadastrarTipo.SelectedValue)
                    };

                    string retorno = exercicioNegocio.Inserir(exercicioInserir);
                    try
                    {
                        int codigo = Convert.ToInt32(retorno);
                        MessageBox.Show("Exercicio cadastrado com sucesso. Código: " + codigo.ToString(), "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        this.DialogResult = System.Windows.Forms.DialogResult.Yes;
                    }
                    catch
                    {
                        MessageBox.Show("Não foi possível cadastrar o exercício. Detalhes: " + retorno, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }

                else if (acaoNaTelaInformada == AcaoNaTela.Alterar)
                {
                    Exercicio exercicioAlterar = new Exercicio()
                    {
                        IDExercicio           = Convert.ToInt32(this.txtCadastrarCodigo.Text),
                        Nome                  = this.txtCadastrarNome.Text,
                        Descricao             = this.rckCadastrarDescricao.Text,
                        DemonstracaoUrlImagem = this.txtCadastrarUrlImagem.Text,
                        DemonstracaoUrlVideo  = txtCadastrarUrlVideo.Text
                    };

                    exercicioAlterar.TipoExercicio = new TipoExercicio()
                    {
                        IDTipoExercicio = Convert.ToInt32(cmbCadastrarTipo.SelectedValue)
                    };

                    string retorno = exercicioNegocio.Alterar(exercicioAlterar);
                    try
                    {
                        int codigo = Convert.ToInt32(retorno);
                        MessageBox.Show("Exercício alterado com sucesso. Código: " + codigo.ToString(), "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        this.DialogResult = System.Windows.Forms.DialogResult.Yes;
                    }
                    catch
                    {
                        MessageBox.Show("Não foi possível alterar o exercício. Detalhes: " + retorno, "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                }
            }
        }
Example #31
0
        public List <Exercicio> GetSimuladoEspecialidadesAgrupadas(int ano, int matricula, int idAplicacao, int idTipoSimulado = (int)Constants.TipoSimulado.Extensivo)
        {
            try
            {
                var retorno = new List <Exercicio>();

                var ids = _exercicioRepository.GetIdsExerciciosRealizadosAluno(matricula, idTipoSimulado);

                var simulados = _exercicioRepository.GetSimuladosByFilters(ano, matricula, idAplicacao, true, idTipoSimulado);

                if (simulados.Count == 0)
                {
                    return(new List <Exercicio>());
                }

                var simuladosAgrupados = this.GetSimuladosDistintosAgrupados(simulados);

                foreach (var sim in simuladosAgrupados)
                {
                    var simulado = new Exercicio
                    {
                        Ano                    = sim.Ano,
                        ExercicioName          = sim.Descricao.Substring(5).Split('-')[0].Trim(),
                        Descricao              = sim.Descricao.Substring(5).Split('-')[1].Trim(),
                        ID                     = sim.ID,
                        DataInicio             = sim.DataInicio,
                        DataFim                = sim.DataFim,
                        Online                 = sim.Online,
                        Ativo                  = true,
                        IdTipoRealizacao       = 1,
                        Duracao                = sim.Duracao,
                        Realizado              = Convert.ToInt32(ChecaAlgumExercicioDoSimuladoFoiRealizado(ids, sim)),
                        DtLiberacaoRanking     = sim.DtLiberacaoRanking,
                        DtUnixLiberacaoRanking = Utilidades.ToUnixTimespan(sim.DtLiberacaoRanking),
                        TipoId                 = sim.TipoId,
                        BitAndamento           = sim.bitAndamento
                    };

                    simulado.Especialidades = _repository.GetEspecialidadesSimulado(simulados, sim);

                    simulado.Ativo = ChecaSimuladoOnlineDeveEstarHabilitado(sim, simulado, ids, matricula);

                    simulado.Label = GetLabelSimulado(simulado.Ativo,
                                                      Convert.ToBoolean(simulado.Realizado),
                                                      Convert.ToBoolean(simulado.Online),
                                                      simulado.DataInicio,
                                                      simulado.DataFim);

                    if (!simulado.Ativo && Convert.ToBoolean(simulado.Realizado) && (idAplicacao == (int)Aplicacoes.MsProMobile || idAplicacao == (int)Aplicacoes.MEDSOFT_PRO_ELECTRON))
                    {
                        simulado.Descricao = string.Format("SIMULADO REALIZADO RANKING EM {0}/{1}", simulado.DtLiberacaoRanking.Day.ToString("00"), simulado.DtLiberacaoRanking.Month.ToString("00"));
                    }

                    retorno.Add(simulado);
                }

                SetarSimuladoAtual(retorno, ano);

                return(retorno);
            }
            catch
            {
                throw;
            }
        }
Example #32
0
 public void addExercicio(int posicao, Exercicio exercicio)
 {
     exercicios.Add(posicao, exercicio);
 }
    public void InsertExercicios(Exercicio exercicio)
    {
        ExercicioDal exercicioDal = new ExercicioDal();

        exercicioDal.Insert(exercicio);
    }
Example #34
0
        public decimal Corrigir(Exercicio Realizado, Exercicio Gabarito)
        {
            decimal TotalQuestoes = Gabarito.Questao.Count;
            decimal acerto        = 0;

            if (Gabarito.Tipo == "C")
            {
                foreach (var itemGabaritoQ in Gabarito.Questao)
                {
                    foreach (var itemRealizadoQ in Realizado.Questao)
                    {
                        if (itemGabaritoQ.Ordem == itemRealizadoQ.Ordem)
                        {
                            foreach (var itemGabaritoA in itemGabaritoQ.Alternativa)
                            {
                                foreach (var itemRealizadoA in itemRealizadoQ.Alternativa)
                                {
                                    if (itemRealizadoA.Conteudo == itemGabaritoA.Conteudo)
                                    {
                                        acerto += 1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                foreach (var itemGabaritoQ in Gabarito.Questao)
                {
                    foreach (var itemRealizadoQ in Realizado.Questao)
                    {
                        if (itemGabaritoQ.Ordem == itemRealizadoQ.Ordem)
                        {
                            foreach (var itemGabaritoA in itemGabaritoQ.Alternativa)
                            {
                                foreach (var itemRealizadoA in itemRealizadoQ.Alternativa)
                                {
                                    if (itemRealizadoA.Ordem == itemGabaritoA.Ordem)
                                    {
                                        if (itemRealizadoA.Tipo == "R")
                                        {
                                            if (itemGabaritoA.Tipo == "C")
                                            {
                                                if (itemRealizadoA.Conteudo == itemGabaritoA.Conteudo)
                                                {
                                                    acerto += 1;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            decimal pontoquestao = 10 / TotalQuestoes;
            decimal nota         = pontoquestao * acerto;

            return(nota);
        }
    public void UpdateExercicios(Exercicio exercicio)
    {
        ExercicioDal exercicioDal = new ExercicioDal();

        exercicioDal.Update(exercicio);
    }