public async Task <IActionResult> Edit(int id, [Bind("TipoCursoId,Tipo")] TipoCurso tipoCurso)
        {
            if (id != tipoCurso.TipoCursoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(tipoCurso);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TipoCursoExists(tipoCurso.TipoCursoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(tipoCurso));
        }
Exemple #2
0
        public async Task <IActionResult> AgregarTipoCurso(TipoCurso obj)
        {
            try
            {
                //if (ModelState.IsValid)
                if (true)
                {
                    if (obj.Id == 0)
                    {
                        _Db.TipoCurso.Add(obj);
                        await _Db.SaveChangesAsync();
                    }
                    else
                    {
                        _Db.Entry(obj).State = EntityState.Modified;
                        await _Db.SaveChangesAsync();
                    }

                    return(RedirectToAction("ListarTipoCursos"));
                }

                //return View();
            }
            catch (Exception ex)
            {
                return(RedirectToAction("ListarTipoCursos"));
            }
        }
Exemple #3
0
        public Curso(string nombre, string profesor, TipoCurso tipo)

        {
            this.nombre   = nombre;
            this.profesor = profesor;
            this.tipo     = tipo;
        }
Exemple #4
0
        public IHttpActionResult PutTipoCurso(int id, TipoCurso tipoCurso)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != tipoCurso.TipoCursoID)
            {
                return(BadRequest());
            }

            db.Entry(tipoCurso).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TipoCursoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
 public TallerExtraProgramatico(List <Evento> eventosExtraP,
                                string nombre, string profesor, TipoCurso tipo) :
     base(nombre, profesor, tipo)
 {
     this.eventosExtraP = eventosExtraP;
     tipo = TipoCurso.Extra;
 }
Exemple #6
0
        public void Update(TipoCurso tipoCurso)
        {
            SqlConnection sqlConnection = new SqlConnection(Utilities.GetConnectionString());
            SqlCommand    sqlCommand    = new SqlCommand(SpTipoCurso.RUD, sqlConnection)
            {
                CommandType = System.Data.CommandType.StoredProcedure
            };

            sqlCommand.Parameters.Add(new SqlParameter("@CODIGO", tipoCurso.Codigo));
            sqlCommand.Parameters.Add(new SqlParameter("@DESCRIPCION", tipoCurso.Descripcion));
            sqlCommand.Parameters.Add(new SqlParameter("@PRECIO", tipoCurso.Precio));
            sqlCommand.Parameters.Add(new SqlParameter("@ESTADO", tipoCurso.Estado));
            sqlCommand.Parameters.Add(new SqlParameter("@SECUENCIA", tipoCurso.Secuencia));
            sqlCommand.Parameters.Add(new SqlParameter("@ACTION", 'U'));
            try
            {
                sqlConnection.Open();
                sqlCommand.ExecuteNonQuery();
            }
            catch (SqlException exc)
            {
                Console.WriteLine(exc.ToString());
            }
            finally
            {
                sqlConnection.Close();
            }
        }
 public Disciplina(int codigo, string nome, TipoCurso tipoCurso, int codCurso)
 {
     Codigo    = codigo;
     Nome      = nome;
     TipoCurso = tipoCurso;
     CodCurso  = codCurso;
 }
Exemple #8
0
        public void Excluir(int id)
        {
            TipoCurso tipoCursoBuscado = ctx.TipoCurso.Find(id);

            ctx.TipoCurso.Remove(tipoCursoBuscado);
            ctx.SaveChanges();
        }
Exemple #9
0
 public Turma(int codigo, TipoCurso tipoCurso, string nome, int codCurso)
 {
     Codigo      = codigo;
     TipoCurso   = tipoCurso;
     Nome        = nome;
     CodigoCurso = codCurso;
 }
Exemple #10
0
        public IEnumerable <TipoCurso> Lov(string descricao = null)
        {
            var filtro = new TipoCurso();

            filtro.Descricao = (descricao != "null")? descricao:null;

            return(_tipoCursoRepository.Listar(filtro));
        }
Exemple #11
0
 public Curso(int codigo, TipoCurso tipoCurso, string nome, int codProfessor, int codFaculdade)
 {
     Codigo          = codigo;
     TipoCurso       = tipoCurso;
     Nome            = nome;
     CodigoProfessor = codProfessor;
     CodigoFaculdade = codFaculdade;
 }
Exemple #12
0
        public void Nome_Deve_Ter_Entre_5_e_50_Caracteres()
        {
            string validacaoEsperada = "O nome deve conter entre 5 e 50 caracteres.";
            var    tipoCurso         = new TipoCurso("Tecnólogo", true);
            var    curso             = new Curso("mater", true, tipoCurso);

            string validacaoQuebrada = curso.ResultadoValidacao.Erros.FirstOrDefault(x => x.Message == validacaoEsperada).Message;

            Assert.AreEqual(validacaoEsperada, validacaoQuebrada);
        }
Exemple #13
0
        public IActionResult CrearTipoCurso(TipoCurso obj)
        {
            ViewBag.id_pais = HttpContext.Session.GetInt32("id_pais");
            ViewBag.usuario = HttpContext.Session.GetString("usuario");

            var id_pais = HttpContext.Session.GetInt32("id_pais");
            var usuario = HttpContext.Session.GetString("usuario");

            return(View(obj));
        }
Exemple #14
0
        public IHttpActionResult GetTipoCurso(int id)
        {
            TipoCurso tipoCurso = db.TipoCursoes.Find(id);

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

            return(Ok(tipoCurso));
        }
Exemple #15
0
        public TipoCurso BuscarPorId(int id)
        {
            TipoCurso tipoCursoBuscado = ctx.TipoCurso.FirstOrDefault(tc => tc.IdTipoCurso == id);

            if (tipoCursoBuscado != null)
            {
                return(tipoCursoBuscado);
            }

            return(null);
        }
        public async Task <IActionResult> Create([Bind("TipoCursoId,Tipo")] TipoCurso tipoCurso)
        {
            if (ModelState.IsValid)
            {
                _context.Add(tipoCurso);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(tipoCurso));
        }
        public void Na_Atualizacao_Do_Curso_Deve_Alterar_DataAtualizacao()
        {
            var      tipoCurso             = new TipoCurso("Tecnólogo", true);
            var      curso                 = new Curso("Ciências da Computação", true, tipoCurso);
            DateTime dataAtuzalicaoCriacao = curso.DataAtualizacao;

            System.Threading.Thread.Sleep(2000);
            curso.AtualizarCurso("Novo Nome de Curso", true, tipoCurso);

            Assert.IsTrue(dataAtuzalicaoCriacao != curso.DataAtualizacao);
        }
        public void DescricaoDeveTerEntre5e50Caracteres()
        {
            string validacaoEsperada = "A descrição deve conter entre 5 e 50 caracteres";
            var    tipoCurso         = new TipoCurso("Tecnólogo", true);
            var    curso             = new Curso("mater", true, tipoCurso);


            string validacaoQuebrada = curso.ResultadoValidacao.Erros.FirstOrDefault(x => x.Message == validacaoEsperada).Message;

            Assert.AreEqual(validacaoEsperada, validacaoQuebrada);
        }
 public TipoCursoDto EntityToDto(TipoCurso TipoCurso)
 {
     if (TipoCurso != null)
     {
         return(new TipoCursoDto()
         {
             IdTipo = TipoCurso.IdTipo,
             NomeTipo = TipoCurso.NomeTipo,
         });
     }
     return(null);
 }
Exemple #20
0
 public CursoCurricular(string nrc, int creditos,
                        List <CursoCurricular> cursosPreRequisito, Especialidad especialidad,
                        List <Evento> eventosCurso, string nombre, string profesor,
                        TipoCurso tipo) : base(nombre, profesor, tipo)
 {
     this.nrc                = nrc;
     this.creditos           = creditos;
     this.cursosPreRequisito = cursosPreRequisito;
     this.especialidad       = especialidad;
     this.eventosCurso       = eventosCurso;
     tipo = TipoCurso.Curricular;
 }
 public async Task Create(TipoCurso model)
 {
     try
     {
         _db.dbSetCAT_TipoCurso.Add(model);
         await _db.SaveChangesAsync();
     }
     catch (Exception e)
     {
         throw new Exception(e.Message, e);
     }
 }
Exemple #22
0
        public IHttpActionResult PostTipoCurso(TipoCurso tipoCurso)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.TipoCursoes.Add(tipoCurso);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = tipoCurso.TipoCursoID }, tipoCurso));
        }
Exemple #23
0
        private void ValidarModelo(TipoCurso tipoCurso)
        {
            if (string.IsNullOrEmpty(tipoCurso.Descricao))
            {
                throw new MensagemException(EnumStatusCode.RequisicaoInvalida, "Descrição do tipo curso não informado");
            }

            if (tipoCurso.Comissao == 0)
            {
                throw new MensagemException(EnumStatusCode.RequisicaoInvalida, "Comissão do tipo curso não informado");
            }
        }
Exemple #24
0
        public IActionResult Post(TipoCurso novoTipoCurso)
        {
            try
            {
                _tipoCursoRepository.Cadastrar(novoTipoCurso);

                return(StatusCode(201));
            }
            catch (Exception error)
            {
                return(BadRequest(error));
            }
        }
        public List <Curso> FindByDescription(string description)
        {
            List <Curso>  cursos     = new List <Curso>();
            SqlConnection connection = new SqlConnection(Utilities.GetConnectionString());
            SqlCommand    sqlCommand = new SqlCommand(SpCurso.FIND_BY_DESCRIPTION, connection)
            {
                CommandType = System.Data.CommandType.StoredProcedure
            };

            sqlCommand.Parameters.Add(new SqlParameter("@DESCRIPCION", description));
            try
            {
                connection.Open();
                SqlDataReader reader = sqlCommand.ExecuteReader();
                while (reader.Read())
                {
                    TipoCurso tipoCurso = new TipoCurso(
                        reader.GetInt32(9),
                        reader.GetString(10),
                        reader.GetString(11),
                        reader.GetFloat(12),
                        Convert.ToChar(reader.GetString(13))
                        );

                    Curso curso = new Curso(
                        reader.GetInt32(0),
                        tipoCurso,
                        reader.GetDateTime(2),
                        reader.GetDateTime(3),
                        reader.GetDateTime(4),
                        reader.GetDateTime(5),
                        reader.GetInt32(6),
                        reader.GetInt32(7),
                        Convert.ToChar(reader.GetString(8))
                        );

                    cursos.Add(curso);
                }
            }
            catch (SqlException exc)
            {
                Console.WriteLine(exc.ToString());
            }
            finally
            {
                connection.Close();
            }


            return(cursos);
        }
Exemple #26
0
        public IHttpActionResult DeleteTipoCurso(int id)
        {
            TipoCurso tipoCurso = db.TipoCursoes.Find(id);

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

            db.TipoCursoes.Remove(tipoCurso);
            db.SaveChanges();

            return(Ok(tipoCurso));
        }
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            txt_tipocurso1.Text = TipoCurso.Obtener_nombre("PETR");

            txt_tipocurso2.Text = TipoCurso.Obtener_nombre("COMP");

            txt_tipocurso3.Text = TipoCurso.Obtener_nombre("CONT");

            txt_tipocurso4.Text = TipoCurso.Obtener_nombre("PLAN");

            txt_tipocurso5.Text = TipoCurso.Obtener_nombre("OTR");
        }
    }
 public static int TipoCursoParaNumero(TipoCurso tipo)
 {
     if (tipo == TipoCurso.Anual)
     {
         return(1);
     }
     else if (tipo == TipoCurso.Semestral)
     {
         return(2);
     }
     else
     {
         return(99);
     }
 }
Exemple #29
0
        public void Atualizar(int id, TipoCurso tipoCursoAtualizado)
        {
            TipoCurso tipoCursoBuscado = ctx.TipoCurso.Find(id);

            if (tipoCursoBuscado != null)
            {
                if (tipoCursoAtualizado.NomeTipoCurso != null)
                {
                    tipoCursoBuscado.NomeTipoCurso = tipoCursoAtualizado.NomeTipoCurso;
                }

                ctx.TipoCurso.Update(tipoCursoBuscado);
                ctx.SaveChanges();
            }
        }
Exemple #30
0
        public Prova Preenche(IDataReader dr)
        {
            int cod = 0, div = 0, uni = 0,
                tipoP = 0, prof = 0, profSup = 0, disciplina = 0, turma = 0, sala = 0, esp = 0, reg;
            TimeSpan hora = new TimeSpan();
            DateTime data = new DateTime();

            int.TryParse(dr["codigo"].ToString(), out cod);
            Codigo = cod;

            int.TryParse(dr["divisao"].ToString(), out div);
            Divisao = DivisaoConversor.NumeroParaDivisao(div);

            int.TryParse(dr["unidade"].ToString(), out uni);
            Unidade = UnidadeConversor.NumeroParaTipoCurso(uni);

            int.TryParse(dr["tipo"].ToString(), out tipoP);
            Tipo = TipoProvaConversor.NumeroParaTipoCurso(tipoP);

            int.TryParse(dr["regime"].ToString(), out reg);
            Regime = TipoCursoConversor.NumeroParaTipoCurso(reg);

            int.TryParse(dr["professor_codigo"].ToString(), out prof);
            Professor_Codigo = prof;

            int.TryParse(dr["professor_suplente_codigo"].ToString(), out profSup);
            Professor_Suplente_Codigo = profSup;

            int.TryParse(dr["sala_codigo"].ToString(), out sala);
            Sala_Codigo = sala;

            int.TryParse(dr["disciplina_codigo"].ToString(), out disciplina);
            Disciplina_Codigo = disciplina;

            int.TryParse(dr["turma_codigo"].ToString(), out turma);
            Turma_Codigo = turma;

            int.TryParse(dr["especial"].ToString(), out esp);
            Especial = (esp == 1);

            DateTime.TryParse(dr["data"].ToString(), out data);
            Data = data;

            TimeSpan.TryParse(dr["hora"].ToString(), out hora);
            Hora = hora;

            return(this);
        }
Exemple #31
0
 public Curso(string _nome, TipoCurso _tipo)
 {
     nome = _nome;
     tipo = _tipo;
     disciplinas = new List<Disciplina>();
 }