public ActionResult Editar(CursoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (SchoolAppEntities db = new SchoolAppEntities())
{
var oTabla = db.Curso.Find(model.IdCurso);
oTabla.Grado = model.Grado;
oTabla.Seccion = model.Seccion;
oTabla.Cant_de_Estudiantes = model.CantDeEstudiantes;
oTabla.Profesor_encargado = model.ProfesorEncargado;
db.Entry(oTabla).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(Redirect("~/Curso/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Cadastrar()
{
var model = new CursoViewModel();
model.TiposCurso = PreencherTipoCurso();
return(View(model));
}
public ActionResult Nuevo(CursoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (SchoolAppEntities db = new SchoolAppEntities())
{
var oTabla = new Curso();
oTabla.Grado = model.Grado;
oTabla.Seccion = model.Seccion;
oTabla.Cant_de_Estudiantes = model.CantDeEstudiantes;
oTabla.Profesor_encargado = model.ProfesorEncargado;
db.Curso.Add(oTabla);
db.SaveChanges();
}
return(Redirect("~/Curso/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task IncluirAsync(CursoViewModel model)
{
AddToken();
var resposta = await _httpClient.PostAsJsonAsync <CursoViewModel>("v1/Cursos", model);
resposta.EnsureSuccessStatusCode();
}
public IActionResult Add(CursoViewModel model)
{
if (ModelState.IsValid)
{
var cookieValue = Request.Cookies["UrlFacultad"];
multyTenancyService.SeleccionarNodoFacultad(cookieValue);
if (!cursoService.ValidateCurso(model.Nombre))
{
var c = new Curso()
{
Nombre = model.Nombre,
Creditos = model.Creditos,
ClaveMatriculacion = model.Clave_Matriculacion,
YearDiactado = model.Year_Diactado,
TipoCurso = model.Tipo_Curso,
DictaCurso = model.Dicta_Curso,
Informacion = model.Informacion,
NotaMinimaAprobacion = model.Nota_Minima_Aprobacion,
NotaMaximaAprobacion = model.Nota_Maxima_Aprobacion,
NotaMinimaExamen = model.Nota_Minima_Examen,
NotaMaximaExamen = model.Nota_Maxima_Examen
};
cursoService.AddCurso(c);
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public ActionResult CrearCurso(CursoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (Sistema_estudiosEntities db = new Sistema_estudiosEntities())
{
/*var newcurso = new CURSO();
* newcurso.nombre = model.nombre;
* newcurso.creador = model.usuario;
*
* db.CURSOes.Add(newcurso);
* db.SaveChanges();*/
db.Database.ExecuteSqlCommand("INSERTAR_CURSO @name, @autor",
new SqlParameter("name", model.nombre),
new SqlParameter("autor", model.usuario)
);
}
return(Redirect("/Curso/CursoIndex"));
}
return(View());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> PutCurso([FromBody] CursoViewModel cursoDetails)
{
_logger.LogInformation("Actualizando los datos del curso.");
var curso = Mapper.Map <Curso>(cursoDetails);
if (!_repository.Cursos.HasNombreUnique(curso))
{
ModelState.AddModelError("Nombre", "Nombre no disponible.");
}
if (!_repository.Cursos.FitSchedule(curso))
{
ModelState.AddModelError("HorasAcademicas", "Sin espacio.");
}
if (ModelState.IsValid)
{
_repository.Cursos.Update(curso);
if (await _repository.Complete())
{
return(Created($"api/cursos/{curso.Id}", Mapper.Map <CursoViewModel>(curso)));
}
}
_logger.LogError("No se pudo actualizar los datos del curso.");
return(BadRequest(ModelState));
}
public async Task <IActionResult> Create([Bind("CodCurso,DescripciónCurso,ImagenCurso,Destacado,FechaCurso,CodCategoria")] CursoViewModel cvw)
{
if (ModelState.IsValid)
{
var curso = new Curso();
try
{
using (var memoryStream = new MemoryStream())
{
await cvw.ImagenCurso.CopyToAsync(memoryStream);
curso.ImagenCurso = memoryStream.ToArray();
}
}
catch (NullReferenceException e) { }
curso.DescripciónCurso = cvw.DescripciónCurso;
curso.CodCategoria = cvw.CodCategoria;
curso.Destacado = cvw.Destacado;
curso.FechaCurso = cvw.FechaCurso;
_context.Add(curso);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
cvw.CategoriasList = new SelectList(_context.Categorias, "CodCategoria", "DescripcionCategoria");
return(View(cvw));
}
public async Task <IActionResult> Adicionar(CursoViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var curso = new Curso
{
Nome = model.Nome,
CargaHoraria = model.CargaHoraria
};
var result = await _service.AddAsync(curso);
return(Ok(new ApiResult
{
Success = true,
Message = "Curso adicionado",
Data = result
}));
}
catch (Exception ex)
{
return(Error(new ApiResult
{
Success = false,
Message = ex.Message
}));
}
}
// GET: Admin/Cursos/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Curso curso = db.Cursos.Where(c => c.Id == id)
.Include(c => c.Blocos)
.FirstOrDefault();
if (curso == null)
{
return(HttpNotFound());
}
var cursoViewModel = new CursoViewModel();
cursoViewModel.Nome = curso.Nome;
cursoViewModel.Blocos = curso.Blocos;
List <int> blocosId = null;
if (cursoViewModel.Blocos != null)
{
blocosId = new List <int>();
cursoViewModel.Blocos.ToList().ForEach(b => blocosId.Add(b.Id));
}
var blocos = db.Blocos.ToList();
ViewBag.ListaBlocos = new MultiSelectList(blocos, "Id", "Nome", blocosId);
return(View(cursoViewModel));
}
public ActionResult Editar(CursoViewModel cursoViewModel)
{
if (ModelState.IsValid)
{
try
{
if (IsCursoDuplicado(cursoViewModel))
{
cursoViewModel.Mensagem = "Já existe um curso com este nome!";
return(View(cursoViewModel));
}
var curso = _unit.CursoRepository.BuscarPorId(cursoViewModel.Id);
curso.Nome = cursoViewModel.Nome;
_unit.CursoRepository.Editar(curso);
_unit.Save();
}
catch (Exception e)
{
cursoViewModel.Mensagem = "Erro ao editar o curso: " + e.Message;
return(View(cursoViewModel));
}
}
else
{
return(View(cursoViewModel));
}
return(RedirectToAction("Listar"));
}
public List <CursoViewModel> ListaCurso(int Idcat)
{
try
{
List <CursoViewModel> vmLista = new List <CursoViewModel>();
List <Cursos> lista = null;
if (Idcat == 0)
{
lista = context.Cursos.ToList();
}
else
{
lista = context.Cursos.Where(x => x.ID_Categoria == Idcat).ToList();
}
if (lista != null)
{
foreach (var item in lista)
{
CursoViewModel temp = new CursoViewModel(item.ID, item.Nombre);
vmLista.Add(temp);
}
}
return(vmLista);
}
catch { return(null); }
}
public async Task <IActionResult> Create([Bind("Name,Summary,Password,StartDate,FinishDate,Category")] CursoViewModel course)
{
if (ModelState.IsValid)
{
Course c = new Course
{
Name = course.Name,
Summary = course.Summary,
// Category =
CreationDate = DateTime.Now,
FinishDate = course.FinishDate,
StartDate = course.StartDate,
Password = course.Password,
ProfessorID = this.User.FindFirstValue(ClaimTypes.NameIdentifier),
CourseID = Guid.NewGuid(),
};
//var idC = _context.Categories.First(u => u.Name == course.Category).CategoryID;
var idC = _context.Categories.First().CategoryID;
c.CategoryID = idC;
_context.Add(c);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
//course.CourseID = Guid.NewGuid();
//_context.Add(course);
//await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Index));
}
//ViewData["CategoryID"] = new SelectList(_context.Categories, "CategoryID", "CategoryID", course.CategoryID);
//ViewData["ProfessorID"] = new SelectList(_context.Professors, "Id", "Id", course.ProfessorID);
return(View(course));
}
// GET: Curso/Edit/5
public ActionResult Edit(int?id)
{
if (!id.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CursoViewModel cursoViewModel = new CursoViewModel()
{
Curso = client.Get(id ?? 0)
};
if (cursoViewModel.Curso == null)
{
return(HttpNotFound());
}
var allProfessores = professorClient.GetAll();
cursoViewModel.TodosProfessores = allProfessores.Select(professor => new SelectListItem
{
Text = professor.Nome,
Value = professor.Id.ToString()
});
return(View(cursoViewModel));
}
public async Task AlterarAsync(Guid Id, CursoViewModel model)
{
AddToken();
var resposta = await _httpClient.PutAsJsonAsync($"v1/Cursos/{Id}", model);
resposta.EnsureSuccessStatusCode();
}
public ActionResult Create(CursoViewModel cursoViewModel, HttpPostedFileBase arquivo)
{
cursoViewModel._categorias = db.Categorias.OrderBy(x => x.Nome).ToList();
if (!ModelState.IsValid) return View(cursoViewModel);
var urlDaImagem = "";
if (arquivo != null)
{
var pic = Path.GetFileName(arquivo.FileName);
var path = Path.Combine(Server.MapPath("~/images"), pic);
// arquivo is uploaded
arquivo.SaveAs(path);
urlDaImagem = "/images/" + pic;
}
var categoria = db.Categorias.Find(cursoViewModel.CategoriaId);
var curso = new Curso(cursoViewModel.Id, cursoViewModel.Nome, cursoViewModel.Url, cursoViewModel.Data, cursoViewModel.Local, categoria, cursoViewModel.Preco, cursoViewModel.Organizador, cursoViewModel.QuantidadeDeInteressados, cursoViewModel.QuantidadeDeParticipantes, cursoViewModel.HoraDeInicio, cursoViewModel.Duracao, cursoViewModel.Descricao, cursoViewModel.Aprovado, urlDaImagem);
db.Cursos.Add(curso);
db.SaveChanges();
return RedirectToAction("Index", "Home");
}
public ActionResult Cadastrar(CursoViewModel cursoViewModel)
{
if (ModelState.IsValid)
{
try
{
if (IsCursoDuplicado(cursoViewModel))
{
cursoViewModel.Mensagem = "Já existe um curso com este nome!";
return(View(cursoViewModel));
}
var curso = new Curso()
{
Nome = cursoViewModel.Nome
};
_unit.CursoRepository.Cadastrar(curso);
_unit.Save();
}
catch (Exception e)
{
cursoViewModel.Mensagem = "Erro ao cadastrar curso: " + e.Message;
return(View(cursoViewModel));
}
}
else
{
return(View(cursoViewModel));
}
return(RedirectToAction("Listar"));
}
public async Task <IActionResult> Create(CursoViewModel cursoViewModel)
{
cursoViewModel = await PopularProfessores(cursoViewModel);
if (!ModelState.IsValid)
{
return(View(cursoViewModel));
}
string fileName = Guid.NewGuid().ToString() + Path.GetExtension(cursoViewModel.UploadCapa.FileName);
if (!await UploadArquivo(cursoViewModel.UploadCapa, fileName, cursoViewModel.ImagemCapa))
{
return(View(cursoViewModel));
}
cursoViewModel.Valor = Decimal.Parse(ObterNumeroDecimal(cursoViewModel.ValorCurrency), new CultureInfo("pt-BR"));
cursoViewModel.ImagemCapa = fileName;
await _cursoService.Add(_mapper.Map <Curso>(cursoViewModel));
if (!OperacaoValida())
{
return(View(cursoViewModel));
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Create([Bind(Include = "Id,Nome,BlocosID")] CursoViewModel cursoViewModel)
{
if (ModelState.IsValid)
{
var curso = new Curso();
curso.Nome = cursoViewModel.Nome;
if (cursoViewModel.BlocosId.Count > 0)
{
curso.Blocos = new List <Bloco>();
foreach (int blocoId in cursoViewModel.BlocosId)
{
var bloco = db.Blocos.Find(blocoId);
if (bloco != null)
{
curso.Blocos.Add(bloco);
}
}
}
db.Cursos.Add(curso);
db.SaveChanges();
return(RedirectToAction("Index"));
}
var blocos = db.Blocos.ToList();
ViewBag.ListaBlocos = new MultiSelectList(blocos, "Id", "Nome", null);
return(View(cursoViewModel));
}
// GET: Cursos/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var model = await _context.Cursos
.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(NotFound());
}
var cursoViewModel = new CursoViewModel
{
Id = model.Id,
nome_curso = model.nome_curso,
carga_horaria_curso = model.carga_horaria_curso,
data_fim = model.data_fim,
data_inicio = model.data_inicio,
};
return(View(cursoViewModel));
}
private void MappingThisFromViewModel(CursoViewModel objeto)
{
this.Id = objeto.Id;
this.Nombre = objeto.Nombre;
this.TotalReunido = objeto.TotalReunido;
this.TotalPagar = objeto.TotalPagar;
this.Colegio = objeto.Colegio;
}
// GET: Curso/Create
public ActionResult Create()
{
CursoViewModel curso = new CursoViewModel();
curso.EstudiantesDisponibles = estudianteRepository.ObtenerEstudiantes();
curso.MateriasDisponibles = materiaRepository.ObtenerMaterias();
return(View(curso));
}
public void Remove(CursoViewModel cursoViewModel)
{
var curso = Mapper.Map <CursoViewModel, Curso>(cursoViewModel);
BeginTransaction();
_cursoService.Remove(curso);
Commit();
}
public ActionResult Create()
{
var categorias = db.Categorias.OrderBy(x => x.Nome).ToList();
var cursoViewModel = new CursoViewModel(null, categorias);
return View(cursoViewModel);
}
public ActionResult ListarComunicados(int idCurso)
{
multyTenancyService.SeleccionarNodoFacultad(Request.Cookies["UrlFacultad"]);
var lista = cursoService.ListarComunicadoCurso(idCurso);
var f = new CursoViewModel(lista);
return(View(f));
}
public ActionResult Cadastrar(string msg)
{
CursoViewModel cursoVM = new CursoViewModel()
{
Msg = msg
};
return(View(cursoVM));
}
public ActionResult Cadastrar(string mensagem)
{
var cursoViewModel = new CursoViewModel()
{
Mensagem = mensagem
};
return(View(cursoViewModel));
}
public async Task <ActionResult> Alterar(CursoViewModel model)
{
if (ModelState.IsValid)
{
await _api.AlterarAsync(model.Id, model);
return(RedirectToAction("Index", new { curso = model.Curso }));
}
return(View(model));
}
public bool IsCursoDuplicado(CursoViewModel cursoViewModel)
{
var cursos = _unit.CursoRepository.BuscarPor(c => c.Nome == cursoViewModel.Nome);
if (cursos.Any() && !(cursos.First().Id == cursoViewModel.Id))
{
return(true);
}
return(false);
}
public async Task <IActionResult> Index(EnumCurso curso)
{
var modelCursos = await _apiCursos.BuscarAsync(curso);
if (modelCursos == null)
{
modelCursos = new CursoViewModel();
}
return(View(modelCursos));
}
