Exemplo n.º 1
0
 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());
         }
     }
 }
Exemplo n.º 2
0
 public frmGestionCurso()
 {
     InitializeComponent();
     InitializeDataGridView();
     CursoService     = new CursoService();
     CategoriaService = new CategoriaService();
 }
Exemplo n.º 3
0
 public ModificarCursoForm(Curso curAMod)
 {
     InitializeComponent();
     cursoModificar = curAMod;
     catService     = new CategoriaService();
     curService     = new CursoService();
 }
 public frmCursoUsuario()
 {
     InitializeComponent();
     InitializeDataGridView();
     UsuarioService = new UsuarioCursoService();
     Cursoservice   = new CursoService();
 }
Exemplo n.º 5
0
 public ABMUsuariosCurso(Curso curso)
 {
     InitializeComponent();
     oCurso = curso;
     lblNombreCurso.Text = oCurso.nombre;
     cursoService        = new CursoService();
 }
Exemplo n.º 6
0
 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()}");
         }
     }
 }
Exemplo n.º 7
0
        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));
            }
        }
Exemplo n.º 8
0
        public void Curso_GetAll_Test()
        {
            CursoService _cursoService = MontaServico();

            var _lista = _cursoService.GetAll();

            Assert.True(_lista.Any());
        }
Exemplo n.º 9
0
 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}");
     }
 }
Exemplo n.º 11
0
        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;
        }
Exemplo n.º 12
0
 public UsuariosCurso(Curso curso)
 {
     InitializeComponent();
     oCurso = curso;
     lblNombreCurso.Text          = oCurso.nombre;
     lblFechaContenido.Text       = oCurso.fecha.ToString();
     lblDescripcionContenido.Text = oCurso.descripcion;
     cursoService = new CursoService();
 }
Exemplo n.º 13
0
 public void LLenarCombo()
 {
     cursoservice = new CursoService(ConfigConnection.ConnectionString);
     Cursos       = cursoservice.ConsultarCursos();
     CmbCurso.Items.Clear();
     foreach (var item in Cursos)
     {
         CmbCurso.Items.Add(item.Nombre);
     }
 }
Exemplo n.º 14
0
 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>();
 }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
 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();
 }
Exemplo n.º 17
0
 public TeacherCoursesController(
     UserService userService,
     CursoService cursoService,
     ProfesorService ctrlService,
     ProfesorCursoService profesorCursoService)
 {
     _cursoService         = cursoService;
     _userService          = userService;
     _ctrlService          = ctrlService;
     _profesorCursoService = profesorCursoService;
 }
Exemplo n.º 18
0
        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);
        }
Exemplo n.º 19
0
        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.");
        }
Exemplo n.º 20
0
 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;
         }
     }
 }
Exemplo n.º 21
0
 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();
 }
Exemplo n.º 22
0
        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.");
        }
Exemplo n.º 23
0
        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.");
        }
Exemplo n.º 24
0
        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));
            }
        }
Exemplo n.º 25
0
        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);
        }
Exemplo n.º 28
0
        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.");
        }
Exemplo n.º 29
0
 public CursoController(CursoService service)
 {
     this.service = service;
 }
Exemplo n.º 30
0
 public CursoController(CursoService CursoService)
 {
     _CursoService = CursoService;
 }
Exemplo n.º 31
0
 public HomeController(CursoService cursoService)
 {
     _cursoService = cursoService;
 }