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);
}
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);
}
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);
}
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));
}
private void addTotalClicadasErradasPorExercicio()
{
Exercicio exercicio = getExercicioAtual();
exercicio.addTotalClicadasErradas();
}
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));
}
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));
}
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();
}
public void Post([FromBody] Exercicio exercicio)
{
business.Incluir(exercicio);
}
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);
}
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);
}
private bool ChecaJaneladeTempoRealizacaoDeSimulado(Exercicio sim)
{
return(DateTime.Now >= Convert.ToDateTime(Utilidades.UnixTimeStampToDateTime(sim.DataInicio)) &&
DateTime.Now <= Convert.ToDateTime(Utilidades.UnixTimeStampToDateTime(sim.DataFim)));
}
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));
}
public static List <Tempo> RetornarTempoPorExercicio(Exercicio exercicio)
{
return(ctx.Tempos.Where(tempo => tempo.Exercicio.ExercicioId == exercicio.ExercicioId).ToList());
}
public static bool CreateExrecicioScopIsValid(this Exercicio exercicio)
{
return(AssertionConcern.IsSatisfiedBy(
AssertionConcern.AssertNotEmpty(exercicio.DsExercicio, "O campo exercício é Obrigatório!")
));
}
/// <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);
}
public static List <Peso> RetornarPesoPorExercicio(Exercicio exercicio)
{
return(ctx.Pesos.Where(peso => peso.Exercicio.ExercicioId == exercicio.ExercicioId).ToList());
}
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);
}
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;
}
}
}
}
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;
}
}
public void addExercicio(int posicao, Exercicio exercicio)
{
exercicios.Add(posicao, exercicio);
}
public void InsertExercicios(Exercicio exercicio)
{
ExercicioDal exercicioDal = new ExercicioDal();
exercicioDal.Insert(exercicio);
}
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);
}
