private void BtnRegistrar_Click(object sender, EventArgs e)
{
cursoservice = new CursoService(ConfigConnection.ConnectionString);
if (TxtInstrumento.Text.Equals("") || CmbEstado.Text.Equals("") || TxtPrecio.Text.Equals(""))
{
MessageBox.Show("Complete todos los campos. ");
}
else
{
try
{
decimal precio = decimal.Parse(TxtPrecio.Text);
Curso curso = new Curso();
curso.Total = precio;
curso.Nombre = (TxtInstrumento.Text).Trim().ToUpper();
curso.Codigo = TxtCodigo.Text;
curso.Estado = CmbEstado.Text;
curso.FechaCreacion = DateTime.Now;
MessageBox.Show(cursoservice.GuardarCurso(curso));
MapearTabla(DtgCurso);
}
catch (FormatException ex)
{
MessageBox.Show("Error. " + ex.Message.ToString());
}
}
}
public frmGestionCurso()
{
InitializeComponent();
InitializeDataGridView();
CursoService = new CursoService();
CategoriaService = new CategoriaService();
}
public ModificarCursoForm(Curso curAMod)
{
InitializeComponent();
cursoModificar = curAMod;
catService = new CategoriaService();
curService = new CursoService();
}
public frmCursoUsuario()
{
InitializeComponent();
InitializeDataGridView();
UsuarioService = new UsuarioCursoService();
Cursoservice = new CursoService();
}
public ABMUsuariosCurso(Curso curso)
{
InitializeComponent();
oCurso = curso;
lblNombreCurso.Text = oCurso.nombre;
cursoService = new CursoService();
}
private void BtnModificar_Click(object sender, EventArgs e)
{
cursoservice = new CursoService(ConfigConnection.ConnectionString);
if (CmbCurso.Text.Equals("") || TxtCodigo.Text.Equals("") || TxtPrecio.Text.Equals("") || CmbEstado.Text.Equals(""))
{
MessageBox.Show("Complete los campos.");
}
else
{
try
{
decimal precio = decimal.Parse(TxtPrecio.Text);
Curso curso = new Curso();
curso = cursoservice.BuscarCurso(TxtCodigo.Text);
curso.Total = precio;
curso.Estado = CmbEstado.Text;
curso.Nombre = TxtNombre.Text;
MessageBox.Show(cursoservice.ModificarCurso(curso));
ICurso.Actualizar();
this.Close();
}
catch (FormatException ex)
{
MessageBox.Show($"Error. {ex.Message.ToString()}");
}
}
}
public async Task <IActionResult> CarregaConteudoCurso(int id, int idConteudo)
{
try
{
//Retorna os dados da inscricao
var retornoDadosInscricao = await _inscricaoUsuarioRepository.ObterPorId(id);
if (retornoDadosInscricao.UsuarioId != Convert.ToInt32(User.Identity.Name))
{
return(Response("Busca invalida", false));
}
var response = await _conteudoRepository.ObterPorId(idConteudo);
//Obter lista prova realizado
var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));
var _cursoService = new CursoService(_moduloRepository, _conteudoUsuarioRepository, Convert.ToInt32(User.Identity.Name));
_cursoService.PreenchConteudoConcluido(response, listaProvaUsuario);
if (!await _cursoService.ValidaConteudoExibicao(response, listaProvaUsuario))
{
return(Response(false));
}
await _cursoService.SalvarVisualizacaoUsuario(response.Id);
return(Response(_mapper.Map <ConteudoDto>(response)));
}
catch (Exception ex)
{
return(ResponseErro(ex));
}
}
public void Curso_GetAll_Test()
{
CursoService _cursoService = MontaServico();
var _lista = _cursoService.GetAll();
Assert.True(_lista.Any());
}
public frmInscripcionCursoUsuario()
{
InitializeComponent();
UsuarioCursoAvanceService = new UsuarioCursoAvanceService();
ListaCursos = new BindingList <UsuarioCursoAvance>();
oCursoService = new CursoService();
ListaCursosAgregar = new BindingList <UsuarioCursoAvance>();
UsuarioCursoService = new UsuarioCursoService();
}
private void AñadirComboBox()
{
cursoService = new CursoService(ConfigConnection.ConnectionString);
Cursos = cursoService.ConsultarCursos();
foreach (var item in Cursos)
{
CmbNombreCurso.Items.Add($"{item.Nombre}");
}
}
private void btAceptarAltaCurso_Click(object sender, EventArgs e)
{
Curso curso = obtenerCurso();
CursoService cser = new CursoService();
cser.AgregarCurso(curso);
MessageBox.Show("Se creó el curso con éxito.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.None);
this.creado = true;
}
public UsuariosCurso(Curso curso)
{
InitializeComponent();
oCurso = curso;
lblNombreCurso.Text = oCurso.nombre;
lblFechaContenido.Text = oCurso.fecha.ToString();
lblDescripcionContenido.Text = oCurso.descripcion;
cursoService = new CursoService();
}
public void LLenarCombo()
{
cursoservice = new CursoService(ConfigConnection.ConnectionString);
Cursos = cursoservice.ConsultarCursos();
CmbCurso.Items.Clear();
foreach (var item in Cursos)
{
CmbCurso.Items.Add(item.Nombre);
}
}
public ABMObjetivosCurso(Curso curso, FormMode opcion)
{
InitializeComponent();
oCurso = curso;
lblNombreCurso.Text = oCurso.nombre;
cursoService = new CursoService();
objetivoService = new ObjetivoService();
formMode = opcion;
objetivos = new List <Objetivo>();
}
public void Curso_GetById_Test()
{
CursoService _cursoService = MontaServico();
var _curso0 = _cursoService.GetById(0);
var _curso1 = _cursoService.GetById(1);
Assert.True(_curso0 == null);
Assert.True(_curso1 != null);
}
public frmAMBCCurso()
{
InitializeComponent();
oCursoService = new CursoService();
oCategoriaService = new CategoriaService();
oObjetivoService = new ObjetivoService();
listaObjetivos = new BindingList <Objetivo>();
listaObjetivosOriginal = new BindingList <Objetivo>();
listaObjetivoseliminar = new BindingList <Objetivo>();
InitializeDataGridView();
}
public TeacherCoursesController(
UserService userService,
CursoService cursoService,
ProfesorService ctrlService,
ProfesorCursoService profesorCursoService)
{
_cursoService = cursoService;
_userService = userService;
_ctrlService = ctrlService;
_profesorCursoService = profesorCursoService;
}
private static CursoService MontaServico()
{
var _opt = new DbContextOptionsBuilder <CursosContext>();
_opt.UseSqlServer("Server = localhost; Database = CursosDB; Trusted_Connection = True");
var _contexto = new CursosContext(_opt.Options);
var _cursoRepository = new Repository <Curso>(_contexto);
CursoService _cursoService = new CursoService(_cursoRepository);
return(_cursoService);
}
public void DeveValidarSeDataInicioEhMenorQueDataAtual()
{
Mock <ICursoRepository> mockCursoRepository = new Mock <ICursoRepository>();
Mock <ICategoriaRepository> mockCategoriaRepository = new Mock <ICategoriaRepository>();
Mock <ICursoService> cursoService = new Mock <ICursoService>();
CursoTestBuilder cursoBuilder = new CursoTestBuilder();
CursoService cursoService1 = new CursoService(mockCursoRepository.Object, mockCategoriaRepository.Object);
var cursoResult = cursoService1.Cadastrar(cursoBuilder.ComDatas(DateTime.Now.AddDays(-1), DateTime.Now.AddDays(2)).ComCategoria(1).Build()).Result;
Assert.AreEqual(cursoResult.Message, "Data início menor que a data atual.");
}
private void CmbCurso_SelectedIndexChanged(object sender, EventArgs e)
{
cursoservice = new CursoService(ConfigConnection.ConnectionString);
Cursos = cursoservice.ConsultarCursos();
foreach (var item in Cursos)
{
if (item.Nombre.Equals(CmbCurso.Text))
{
TxtCodigo.Text = item.Codigo;
TxtPrecio.Text = item.Total.ToString();
CmbEstado.Text = item.Estado;
TxtNombre.Text = item.Nombre;
}
}
}
private void MapearTablaFiltroEstado(DataGridView dtg, string estado)
{
cursoservice = new CursoService(ConfigConnection.ConnectionString);
dtg.Rows.Clear();
foreach (var item in cursoservice.FiltroEstadoCurso(estado))
{
int n = dtg.Rows.Add();
dtg.Rows[n].Cells[0].Value = item.Codigo;
dtg.Rows[n].Cells[1].Value = item.Nombre;
dtg.Rows[n].Cells[2].Value = item.Total;
dtg.Rows[n].Cells[3].Value = item.Estado;
dtg.Rows[n].Cells[4].Value = item.FechaCreacion;
}
TxtTodos.Text = cursoservice.FiltroEstadoCurso(estado).Count.ToString();
}
public void DeveValidarSeTemUmCursoPeriodoJaCadastradoParaOCurso()
{
CursoTestBuilder cursoBuilder = new CursoTestBuilder();
Mock <ICursoRepository> mockCursoRepository = new Mock <ICursoRepository>();
Mock <ICategoriaRepository> mockCategoriaRepository = new Mock <ICategoriaRepository>();
Mock <ICursoService> mockCursoService = new Mock <ICursoService>();
mockCursoRepository.Setup(x => x.VerificaCursoPorPeriodo(It.IsAny <DateTime>(), It.IsAny <DateTime>(), null, false)).Returns(false);
CursoService cursoService = new CursoService(mockCursoRepository.Object, mockCategoriaRepository.Object);
var cursoResult = cursoService.Cadastrar(cursoBuilder.ComDatas(DateTime.Now.AddDays(2), DateTime.Now.AddDays(3)).ComCategoria(1).Build()).Result;
Assert.AreEqual(cursoResult.Message, "Existe(m) curso(s) planejados(s) dentro do período informado.");
}
public void DeveRetornarCategoriaNaoExiste()
{
CursoTestBuilder cursoBuilder = new CursoTestBuilder();
Mock <ICursoRepository> mockCursoRepository = new Mock <ICursoRepository>();
Mock <ICategoriaRepository> mockCategoriaRepository = new Mock <ICategoriaRepository>();
Mock <ICursoService> mockCursoService = new Mock <ICursoService>();
mockCursoRepository.Setup(x => x.VerificaCursoPorPeriodo(It.IsAny <DateTime>(), It.IsAny <DateTime>(), null, false)).Returns(true);
CursoService cursoService = new CursoService(mockCursoRepository.Object, mockCategoriaRepository.Object);
var cursoResult = cursoService.Cadastrar(cursoBuilder.ComDatas(DateTime.Now.AddDays(2), DateTime.Now.AddDays(3)).ComCategoria(1).Build()).Result;
Assert.AreEqual(cursoResult.Message, "Categora não existe.");
}
public async Task <IActionResult> CarregaModuloCurso(int id)
{
try
{
//Valida se esta acesso do curso
var retornoDadosInscricao = await _inscricaoUsuarioRepository.ObterPorId(id);
if (retornoDadosInscricao.UsuarioId != Convert.ToInt32(User.Identity.Name))
{
return(Response("Busca invalida", false));
}
var retorno = await _moduloRepository.Buscar(x => x.CursoId.Equals(retornoDadosInscricao.ProcessoInscricao.CursoId));
var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));
var _cursoService = new CursoService(_moduloRepository, _conteudoUsuarioRepository, Convert.ToInt32(User.Identity.Name));
_cursoService.PreencheModuloConteudoConcluido(retorno, listaProvaUsuario);
var listaLiberacaoModulo = new List <ModuloDto>();
foreach (var modulo in retorno)
{
if (modulo.LiberacaoModulos.Count > 0)
{
if (DateTime.Now > modulo.LiberacaoModulos.LastOrDefault().DataInicio)
{
listaLiberacaoModulo.Add(_mapper.Map <ModuloDto>(modulo));
}
}
else
{
listaLiberacaoModulo.Add(_mapper.Map <ModuloDto>(modulo));
}
}
return(Response(listaLiberacaoModulo.OrderBy(c => c.Ordem)));
}
catch (Exception ex)
{
return(ResponseErro(ex));
}
}
public async Task <IActionResult> CarregaCurso(int id)
{
try
{
//Retorna os dados da inscricao
var retornoDadosInscricao = await _inscricaoUsuarioRepository.ObterPorId(id);
if (retornoDadosInscricao.UsuarioId != Convert.ToInt32(User.Identity.Name))
{
return(Response("Busca invalida", false));
}
//Obter lista prova realizado
var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));
//Busca o ultimo conteudo do usuario
var retornoConteudoUsuario = await _conteudoUsuarioRepository.Buscar(x => x.UsuariosId == Convert.ToInt32(User.Identity.Name) && x.Conteudo.Modulo.CursoId == retornoDadosInscricao.ProcessoInscricao.CursoId);
var _cursoService = new CursoService(_moduloRepository, _conteudoUsuarioRepository, Convert.ToInt32(User.Identity.Name));
if (retornoConteudoUsuario.Length > 0)
{
var ultimoConteudo = retornoConteudoUsuario.OrderByDescending(c => c.DataConclusao).Select(c => c.Conteudo).FirstOrDefault();
await _cursoService.SalvarVisualizacaoUsuario(ultimoConteudo.Id);
_cursoService.PreenchConteudoConcluido(ultimoConteudo, listaProvaUsuario);
return(Response(_mapper.Map <ConteudoDto>(ultimoConteudo)));
}
var ultimoConteudoVisualizado = retornoDadosInscricao.ProcessoInscricao.Curso.Modulo.FirstOrDefault().Conteudos[0];
await _cursoService.SalvarVisualizacaoUsuario(ultimoConteudoVisualizado.Id);
_cursoService.PreenchConteudoConcluido(ultimoConteudoVisualizado, listaProvaUsuario);
return(Response(_mapper.Map <ConteudoDto>(ultimoConteudoVisualizado)));
}
catch (Exception ex)
{
return(ResponseErro(ex));
}
}
private void AgregarCursos()
{
cursoService = new CursoService(ConfigConnection.ConnectionString);
int opcion = 5;
try
{
DetalleCurso detalle = null;
int numero = VerificarComboBox(TxtUnidades.Text);
foreach (var item in Cursos)
{
if (item.Nombre.Equals(CmbNombreCurso.Text))
{
foreach (var item2 in Factura.VerListaCursos())
{
if (item2.Curso.Nombre.Equals(CmbNombreCurso.Text))
{
detalle = item2;
opcion = 1;
}
}
if (Factura.VerListaCursos().Where(C => C.Curso.Nombre.Equals(CmbNombreCurso.Text)).ToList().Count == 0)
{
opcion = 0;
}
if (opcion == 0)
{
Factura.AgregarDetalleCurso(item, numero);
}
}
if (opcion == 1 && item.Nombre.Equals(CmbNombreCurso.Text))
{
Factura.DetallesCursoFactura.Remove(detalle);
Factura.AgregarDetalleCurso(item, numero);
}
}
}
catch (FormatException ex)
{
MessageBox.Show($"Error. {ex.Message.ToString()}");
}
}
public CursoServiceTest()
{
var faker = new Faker();
_cursoDto = new CursoDto
{
Nome = faker.Random.Words(),
Valor = faker.Random.Double(100, 5000),
Descricao = faker.Lorem.Paragraph(),
PublicoAlvo = faker.Random.Enum <PublicoAlvo>().ToString(),
DataCadastro = DateTime.Now,
CargaHoraria = faker.Random.Double(1, 100),
Ativo = faker.Random.Bool()
};
_cursoRepositorioMock = new Mock <IRepositoryCurso>();
_cursoService = new CursoService(_cursoRepositorioMock.Object);
}
public void DeveRetornarCursoCadastradoComSucesso()
{
CursoTestBuilder cursoBuilder = new CursoTestBuilder();
Categoria categoria = new Categoria()
{
Codigo = 1, Descricao = "Programacao"
};
Mock <ICursoRepository> mockCursoRepository = new Mock <ICursoRepository>();
Mock <ICategoriaRepository> mockCategoriaRepository = new Mock <ICategoriaRepository>();
Mock <ICursoService> mockCursoService = new Mock <ICursoService>();
mockCursoRepository.Setup(x => x.VerificaCursoPorPeriodo(It.IsAny <DateTime>(), It.IsAny <DateTime>(), null, false)).Returns(true);
mockCategoriaRepository.Setup(p => p.GetEntityById(It.IsAny <long>())).Returns(Task.FromResult(categoria));
CursoService cursoService = new CursoService(mockCursoRepository.Object, mockCategoriaRepository.Object);
var cursoResult = cursoService.Cadastrar(cursoBuilder.ComDatas(DateTime.Now.AddDays(2), DateTime.Now.AddDays(3)).ComCategoria(1).Build()).Result;
Assert.AreEqual(cursoResult.Message, "Curso cadastrado com sucesso.");
}
public CursoController(CursoService service)
{
this.service = service;
}
public CursoController(CursoService CursoService)
{
_CursoService = CursoService;
}
public HomeController(CursoService cursoService)
{
_cursoService = cursoService;
}
