public IActionResult Put(Guid id, [FromBody] CursoDTO value)
{
Resposta <Categoria> objCategoriaResposta = new CategoriaBusiness(objTesteCastGroupContext).GetByCodigo(value.CategoriaCodigo);
if (!objCategoriaResposta.Sucesso)
{
return(StatusCode(500, objCategoriaResposta.Mensagem));
}
Resposta <Curso> objCursoResposta = new CursoBusiness(objTesteCastGroupContext).Get(id);
if (!objCursoResposta.Sucesso)
{
return(StatusCode(500, objCursoResposta.Mensagem));
}
else
{
objCursoResposta.Objeto.DescricaoAssunto = value.DescricaoAssunto;
objCursoResposta.Objeto.DataInicio = value.DataInicio;
objCursoResposta.Objeto.DataTerminio = value.DataTerminio;
objCursoResposta.Objeto.QuantidadeAluno = value.QuantidadeAluno;
objCursoResposta.Objeto.Categoria = objCategoriaResposta.Objeto;
objCursoResposta = new CursoBusiness(objTesteCastGroupContext).Update(objCursoResposta.Objeto);
if (!objCursoResposta.Sucesso)
{
return(StatusCode(500, objCursoResposta.Mensagem));
}
else
{
return(Ok(objCursoResposta.Objeto));
}
}
}
public CursoDTO Get(int id)
{
var query = _services.GetById(id);
CursoDTO dtos = Models.Factory.FactoryCursoDTO.GetInstance().CreateDTO(query);
return(dtos);
}
public IActionResult Post([FromBody] CursoDTO value)
{
Resposta <Categoria> objCategoriaResposta = new CategoriaBusiness(objTesteCastGroupContext).GetByCodigo(value.CategoriaCodigo);
if (!objCategoriaResposta.Sucesso)
{
return(StatusCode(500, objCategoriaResposta.Mensagem));
}
Curso objCurso = new Curso()
{
DescricaoAssunto = value.DescricaoAssunto,
DataInicio = value.DataInicio,
DataTerminio = value.DataTerminio,
QuantidadeAluno = value.QuantidadeAluno,
Categoria = objCategoriaResposta.Objeto
};
Resposta <Curso> objCursoResposta = new CursoBusiness(objTesteCastGroupContext).Save(objCurso);
if (!objCursoResposta.Sucesso)
{
return(StatusCode(500, objCursoResposta.Mensagem));
}
else
{
return(Ok(objCursoResposta.Objeto));
}
}
public ResultSet <CursoDTO> Delete(Guid id)
{
ResultSet <CursoDTO> result;
CursoDTO obj = new CursoDTO();
try
{
obj = (CursoDTO)_cursoRepository.GetById(id);
if (obj != null)
{
_cursoRepository.Remove(id);
_cursoRepository.Commit();
result = new ResultSet <CursoDTO>(obj, MensagensGeral.REMOVE_SUCESSO);
}
else
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.REMOVE_ERRO);
}
}
catch (Exception EX)
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.EXCECAO + EX.Message);
}
return(result);
}
public IActionResult Salvar(CursoDTO cursoTemporario)
{
if (ModelState.IsValid)
{
Curso curso = new Curso();
if (cursoTemporario.Id == 0)
{
curso.Nome = cursoTemporario.Nome;
curso.Descricao = cursoTemporario.Descricao;
database.Curso.Add(curso);
}
else
{
Curso cursoDoBanco = database.Curso.First(registro => registro.Id == cursoTemporario.Id);
cursoDoBanco.Nome = cursoTemporario.Nome;
cursoDoBanco.Descricao = cursoTemporario.Descricao;
}
database.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ViewData["aux"] = cursoTemporario.Id;
return(View("../Curso/CadastrarCurso"));
}
}
public ActionResult Edit(Curso curso)
{
if (ModelState.IsValid)
{
CursoServiceRemoto.CursoServiceClient cliente = new CursoServiceRemoto.CursoServiceClient();
ProfessorServiceRemote.ProfessorServiceClient clienteProfessor = new ProfessorServiceRemote.ProfessorServiceClient();
List <Professor> professores = new List <Professor>();
curso.Professores = new List <Professor>();
Professor professor;
for (int i = 0; i < curso.ProfessoresId.Length; i++)
{
professor = Mapper.Map <AcmeCursos.Presentation.ProfessorServiceRemote.ProfessorDTO, Professor>(clienteProfessor.Find(curso.ProfessoresId[i]));
professores.Add(professor);
}
CursoDTO cursoDTO = Mapper.Map <Curso, CursoDTO>(curso);
cursoDTO.Professores = Mapper.Map <List <ProfessorDTO> >(professores);
bool retorno = cliente.Update(cursoDTO);
TempData["Sucesso"] = true;
TempData["Mensagem"] = retorno ? "Curso atualizado com sucesso" : "Curso não pode ser atualizado";
return(RedirectToAction("Index"));
}
return(View("Edit", curso));
}
public List <CursoDTO> ObterMeusCursos(DocenteDTO dto)
{
List <CursoDTO> lista = new List <CursoDTO>();
try
{
BaseDados.ComandText = "stp_ACA_DOCENTE_OBTERMEUSCURSOS";
BaseDados.AddParameter("DOCENTE", dto.Codigo);
MySqlDataReader dr = BaseDados.ExecuteReader();
while (dr.Read())
{
CursoDTO objCurso = new CursoDTO();
objCurso.Codigo = int.Parse(dr[0]);
objCurso.Nome = dr[1];
lista.Add(objCurso);
}
}
catch (Exception ex)
{
dto.MensagemErro = ex.Message.Replace("'", "");
}
finally
{
BaseDados.FecharConexao();
}
lista.Insert(0, new CursoDTO(-1, "SELECCIONE"));
return(lista);
}
public CursoDTO BaixarCurso(string email, string password, string urlCurso, string pathSave)
{
Email = email;
Password = password;
PathSave = pathSave;
//Validação
if (!urlCurso.Contains("https://cursos.alura.com.br/course/"))
{
throw new ArgumentException("O link do curso deve ser no seguinte formato: https://cursos.alura.com.br/course/[nome do curso]");
}
//Faz o login caso esteja deslogado
if (!Logado())
{
Logar();
}
string response = _browser.Navigate($"{urlCurso.Replace("course", "courses")}/tryToEnroll");
var curso = new CursoDTO();
curso.Url = urlCurso;
curso.Nome = response.ValorEntre("<h2 class=\"task-menu-header-info-title-text\">", "</h2>");
curso.Aulas = PopularAulas(curso, response);
BaixarVideos(curso);
return(curso);
}
public async Task <IActionResult> Edit(CursoDTO cursoDTO)
{
var CursoDTO = await _context.Curso.Include("Asignatura").FirstOrDefaultAsync(u => u.Id == cursoDTO.Id);
var asignatura = await _context.Asignatura.FindAsync(cursoDTO.Asignatura.Id);
if (CursoDTO == null)
{
return(NotFound());
}
CursoDTO.Asignatura = asignatura;
_context.Entry(CursoDTO).CurrentValues.SetValues(cursoDTO);
try
{
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetCurso), new { id = cursoDTO.Id }, cursoDTO));
}
catch (DbUpdateConcurrencyException)
{
if (!CursoExists(cursoDTO.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
public void Armazenar(CursoDTO cursoDto)
{
if (!Enum.TryParse <PublicoAlvo>(cursoDto.PublicoAlvo, out var publicoAlvo))
{
throw new ArgumentException("Publico Alvo invalido");
}
var cursoJaSalvo = _cursoRepository.Obter(cursoDto.Nome);
if (cursoJaSalvo != null)
{
throw new ArgumentException("Nome do curso ja consta no banco de dados");
}
var curso = new Curso
(
cursoDto.Nome,
cursoDto.CargaHorario,
publicoAlvo,
cursoDto.Valor,
cursoDto.Descricao
);;
_cursoRepository.Adicionar(curso);
}
public ResultSet <CursoDTO> Update(CursoDTO curso)
{
ResultSet <CursoDTO> result;
Curso obj = null;
if (curso != null)
{
try
{
obj = _cursoRepository.GetById(curso.Id);
if (IsFieldObrigatory(curso))
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.CAMPO_OBRIGATORIO_NAO_PREENCHIDO);
}
else
{
if (IsPeriodConflit(curso))
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.PERIODO_ALERTA_MESMO_PERIODO);
}
else
{
if (curso.DataTermino <= curso.DataInicio)
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.PERIODO_ALERTA_TERMINO_INFERIOR);
}
else
{
if (obj != null)
{
obj.CategoriaId = curso.CategoriaId;
obj.DataInicio = curso.DataInicio;
obj.DataTermino = curso.DataTermino;
obj.QuantidadeDeAlunos = curso.QuantidadeDeAlunos;
obj.Descricao = curso.Descricao;
_cursoRepository.Update(obj);
_cursoRepository.Commit();
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.ALTERA_SUCESSO);
}
else
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.ALTERA_ERRO);
}
}
}
}
}
catch (Exception EX)
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.EXCECAO + EX.Message);
}
}
else
{
result = new ResultSet <CursoDTO>((CursoDTO)obj, MensagensGeral.ALTERA_ERRO);
}
return(result);
}
public async Task <IActionResult> Post(CursoDTO cursoDTO)
{
var sucesso = await _armazenador.Armazenar(cursoDTO);
return(sucesso
? Created("", cursoDTO)
: BadRequest());
}
private bool IsFieldObrigatory(CursoDTO curso)
{
if (string.IsNullOrEmpty(curso.Descricao) || curso.DataInicio == null || curso.DataTermino == null || curso.CategoriaId == null)
{
return(true);
}
return(false);
}
public frmcursosingle(CursoDTO dto, String OP)
{
InitializeComponent();
Operation = OP;
dtoaction = dto;
if (OP == "A")
{
button1.Text = "Agregar";
button2.Text = "Cancelar";
this.Text = "Alta Curso";
}
else if (OP == "M")
{
txtIdcurso.Text = dto.id_curso.ToString();
txtdescmateria.Text = new MateriaProxy().Get(dto.id_materia).desc_materia;
txtcomision.Text = new ComisionProxy().Get(dto.id_comision).desc_comision;
txtcalendario.Text = dto.anio_calendario.ToString();
txtcupo.Text = dto.cupo.ToString();
foreach (var item in dto.docentes_cursos)
{
if (item.cargo == (Int32)EnumDocente.Titula)
{
codtitular = item.id_docente;
coddictado = item.id_dictado;
var persona = new PersonaProxy().Get(item.id_docente);
txttitular.Text = persona.nombre + "" + persona.apellido;
}
else if (item.cargo == (Int32)EnumDocente.Auydante)
{
codAyudante = item.id_docente;
coddictado = item.id_dictado;
var persona = new PersonaProxy().Get(item.id_docente);
txtjtp.Text = persona.nombre + "" + persona.apellido;
}
}
button1.Text = "Actualizar";
button2.Text = "Cancelar";
this.Text = "Actualizar Curso";
}
else if (OP == "D")
{
txtIdcurso.Text = dto.id_curso.ToString();
txtdescmateria.Text = new MateriaProxy().Get(dto.id_materia).desc_materia;
txtcomision.Text = new ComisionProxy().Get(dto.id_comision).desc_comision;
txtcalendario.Text = dto.anio_calendario.ToString();
txtcupo.Text = dto.cupo.ToString();
txtIdcurso.ReadOnly = true;
txtdescmateria.ReadOnly = true;
txtcomision.ReadOnly = true;
txtcalendario.ReadOnly = true;
txtcupo.ReadOnly = true;
button1.Text = "Eliminar";
button2.Text = "Cancelar";
this.Text = "Eliminar Curso";
}
}
public IEnumerable <Curso> Lov(string descricao)
{
var filtro = new CursoDTO
{
Nome = (descricao != "null") ? descricao : null
};
return(_cursoRepository.Listar(filtro));
}
public bool Delete(CursoDTO curso)
{
try
{
return(CursoRepository.Delete(Mapper.Map <CursoDTO, Curso>(curso)));
}catch (Exception) {
throw new ServiceFaultException("Não foi possível excluir o curso");
}
}
public async Task <IActionResult> InsertCurso(CursoDTO cursoDTO)
{
var curso = _mapper.Map <Curso>(cursoDTO);
await _cursoService.InsertCurso(curso);
cursoDTO = _mapper.Map <CursoDTO>(curso);
var response = new APIResponse <CursoDTO>(cursoDTO);
return(Ok(response));
}
private void DeleteCurso()
{
CursoDTO dtodelate = new CursoDTO()
{
Id = dtoaction.id_curso,
};
Myproxy().Delete(dtodelate);
this.Close();
}
public IEnumerable <Curso> Listar(CursoDTO cursoVo)
{
return(base.Query(x =>
(x.Id == cursoVo.Id || !cursoVo.Id.HasValue) &&
(x.TipoCursoId == cursoVo.TipoCursoId || !cursoVo.TipoCursoId.HasValue) &&
(EF.Functions.Like(x.Nome, "%" + cursoVo.Nome + "%") || string.IsNullOrEmpty(cursoVo.Nome)
), x => x.Id).Include(t => t.TipoCurso)
.Include(c => c.Docentes).ThenInclude(c => c.Docente)
.Include(c => c.ConteudosProgramaticos).ThenInclude(c => c.ConteudoProgramatico).ToList());
}
private bool IsPeriodConflit(CursoDTO curso)
{
return(_cursoRepository.GetAll().Where(x => curso.Id != x.Id && (
curso.DataInicio >= x.DataInicio && curso.DataInicio <= x.DataTermino ||
curso.DataInicio <= x.DataTermino && curso.DataTermino >= x.DataTermino ||
curso.DataInicio >= x.DataInicio && curso.DataTermino <= x.DataTermino ||
curso.DataInicio <= x.DataInicio && curso.DataTermino >= x.DataTermino ||
curso.DataInicio <= x.DataInicio && curso.DataTermino <= x.DataTermino && curso.DataTermino >= x.DataInicio)
).Any());
}
public async Task <HttpResponseMessage> Create([Bind("Id,Numero,Name")] CursoDTO cursoDTO)
{
var curso = _mapper.Map <Curso>(cursoDTO);
_context.Entry(curso).State = EntityState.Unchanged;
_context.Curso.Add(curso);
await _context.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.Created));
}
public async Task <IActionResult> Put(long Id, CursoDTO cursoDTO)
{
var curso = _mapper.Map <Curso>(cursoDTO);
curso.Id = Id;
var result = await _cursoService.UpdateCurso(curso);
cursoDTO = _mapper.Map <CursoDTO>(curso);
var response = new APIResponse <CursoDTO>(cursoDTO);
return(Ok(response));
}
public ResultSet <CursoDTO> Save(CursoDTO curso)
{
ResultSet <CursoDTO> result = null;
if (curso.DataInicio >= DateTime.Now)
{
CursoDTO obj = null;
try
{
if (IsFieldObrigatory(curso))
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.CAMPO_OBRIGATORIO_NAO_PREENCHIDO);
}
else
{
if (IsPeriodConflit(curso))
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.PERIODO_ALERTA_MESMO_PERIODO);
}
else
{
if (curso.DataTermino <= curso.DataInicio)
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.PERIODO_ALERTA_TERMINO_INFERIOR);
}
else
{
obj = (CursoDTO)_cursoRepository.Save((Curso)curso);
if (obj != null)
{
_cursoRepository.Commit();
result = new ResultSet <CursoDTO>(obj, MensagensGeral.CADASTRA_SUCESSO);
}
else
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.CADASTRA_ERRO);
}
}
}
}
}
catch (Exception EX)
{
result = new ResultSet <CursoDTO>(obj, MensagensGeral.EXCECAO + EX.Message);
}
}
else
{
result = new ResultSet <CursoDTO>(curso, MensagensGeral.PERIODO_ALERTA_INFERIOR);
}
return(result);
}
public IActionResult Editar(int id)
{
Curso curso = database.Curso.First(registro => registro.Id == id);
CursoDTO cursoTemporario = new CursoDTO();
cursoTemporario.Id = curso.Id;
cursoTemporario.Nome = curso.Nome;
cursoTemporario.Descricao = curso.Descricao;
ViewData["aux"] = id;
return(View("CadastrarCurso", cursoTemporario));
}
//Update, Actualizar
public void ActualizarCurso(CursoDTO curso)
{
using (var db = new BDEscuelaContext())
{
var _curso = new Curso();
_curso.Id = curso.Id;
_curso.Nombre = curso.Nombre;
_curso.Tiempo = curso.Tiempo;
_curso.FechaInicio = curso.FechaInicio;
_curso.FechaFin = curso.FechaFin;
db.Entry(_curso).State = EntityState.Modified;
db.SaveChanges();
}
}
public IActionResult Editar(int id)
{
var curso = _cursoRepositorio.ObterPorId(id);
var dto = new CursoDTO
{
Id = curso.Id,
Nome = curso.Nome,
Descricao = curso.Descricao,
CargaHoraria = curso.CargaHoraria,
Valor = curso.Valor
};
return(View("NovoOuEditar", dto));
}
public CursoDTO ObternerCurso(int id)
{
var curso = new CursoDTO();
using (var db = new BDEscuelaContext())
{
var _curso = db.Cursos.Find(id);
curso.Id = _curso.Id;
curso.Nombre = _curso.Nombre;
curso.Tiempo = _curso.Tiempo;
curso.FechaInicio = _curso.FechaInicio;
curso.FechaFin = _curso.FechaFin;
}
return(curso);
}
//crear
public CursoDTO InsertarCurso(CursoDTO curso)
{
var _curso = new Curso();
using (var db = new BDEscuelaContext())
{
_curso.Nombre = curso.Nombre;
_curso.Tiempo = curso.Tiempo;
_curso.FechaInicio = curso.FechaInicio;
_curso.FechaFin = curso.FechaFin;
db.Cursos.Add(_curso);
db.SaveChanges();
}
return(curso);
}
public ArmazenadorDeCursoTest()
{
var fake = new Faker();
_cursoDTO = new CursoDTO
{
Nome = fake.Random.Words(),
CargaHoraria = fake.Random.Double(50, 1000),
PublicoAlvo = "Estudante",
Valor = fake.Random.Double(1000, 2000)
};
_cursoRepositorioMock = new Mock <ICursoRepositorio>();
_armazenadorDeCurso = new ArmazenadorDeCurso(_cursoRepositorioMock.Object);
}
public CursoDTO FindWithProfessores(int id)
{
CursoDTO curso = new CursoDTO();
try
{
curso = Mapper.Map <Curso, CursoDTO>(CursoRepository.FindWithProfessores(id));
}
catch (Exception)
{
throw new ServiceFaultException("Não foi possível recuperar o curso");
}
return(curso);
}
