public async Task <IActionResult> Atualizar(TurmaViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_turmaService.Buscar(p => p.Id == model.Id).Result.Any())
{
return(NotFound());
}
try
{
var turma = _mapper.Map <Turma>(model);
await _turmaService.Atualizar(turma);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Accepted(nameof(ObterPorId), new { id = model.Id }));
}
// GET: Alunos/Create
public IActionResult Create()
{
var turma = new TurmaViewModel();
turma.cursos = GetCurso();
return(View(turma));
}
//
// GET: /TurmaViewModels/Create
public ActionResult CadastrarTurma()
{
TurmaViewModel viewModel = null;
var dataAtual = DateTime.Today;
try
{
viewModel = new TurmaViewModel();
viewModel.ListaCR = CRViewModel.MapToListViewModel(BL.CR.Get().ToList());
viewModel.ListaMatrizes = MatrizViewModel.MapToListViewModel(BL.Matriz.Get(a => (a.Aprovado == 1 && a.Status == 1 && a.Modalidade.CR.Any()) && (a.DataFim >= dataAtual || a.DataFim == null)).ToList());
viewModel.ListaTurnos = TurnoViewModel.MapToListViewModel(BL.Turno.Get().ToList());
viewModel.ListaUnidades = UnidadeViewModel.MapToListViewModel(BL.Unidade.Get().ToList());
viewModel.ListaUsuario = new List <UsuarioViewModel>();
viewModel.Status = 0;
viewModel.TipoOferta = 0;
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página CadastrarModalidade", ex);
}
return(View(viewModel));
}
private void PopularListasTurmaVM(int id, DateTime dataAtual, TurmaViewModel viewModel)
{
viewModel.ListaCR = CRViewModel.MapToListViewModel(BL.CR.Get().ToList());
var matrizes = BL.Matriz.Get(a => a.Aprovado == 1 && a.Status == 1 && a.Modalidade.CR.Any()).ToList();
viewModel.ListaMatrizes = MatrizViewModel.MapToListViewModel(matrizes);
viewModel.ListaTurnos = TurnoViewModel.MapToListViewModel(BL.Turno.Get().ToList());
viewModel.ListaUnidades = UnidadeViewModel.MapToListViewModel(BL.Unidade.Get().ToList());
viewModel.ListaUsuario = new List <UsuarioViewModel>();
if (viewModel.ListaReprovacaoTurma == null)
{
viewModel.ListaReprovacaoTurma = BL.ReprovacaoTurma.Get(r => r.IdTurma == id).OrderByDescending(a => a.IdReprovacaoTurma).ToList();
}
//viewModel.ListaMatrizModulo = MatrizViewModel.MapToViewModel(viewModel.Matriz);
var datas = BL.Turma.GetDatasMinMax(id).FirstOrDefault();
if (datas.DataFim != null && datas.Dataini != null)
{
viewModel.DataIniView = datas.Dataini.Value == null ? "" : datas.Dataini.Value.ToShortDateString();
viewModel.DataFimView = datas.DataFim.Value == null ? "" : datas.DataFim.Value.ToShortDateString();
}
else
{
viewModel.DataIniView = "";
viewModel.DataFimView = "";
}
}
public async Task <IActionResult> Create(TurmaViewModel turmaViewModel)
{
if (ModelState.IsValid)
{
var cursos = await _context.Cursos.FirstOrDefaultAsync(t => t.Id == turmaViewModel.id_curso);
if (cursos == null)
{
return(NotFound());
}
var turma = new Turma
{
Id = turmaViewModel.Id,
nome_turma = turmaViewModel.nome_turma,
Curso = cursos,
id_curso = turmaViewModel.id_curso,
};
_context.Add(turma);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(turmaViewModel));
}
public async Task AlterarAsync(Guid Id, TurmaViewModel model)
{
AddToken();
var resposta = await _httpClient.PutAsJsonAsync($"v1/Turma/{Id}", model);
resposta.EnsureSuccessStatusCode();
}
public async Task <ResponseApi <TurmaViewModel> > Editar(TurmaViewModel model)
{
var restRequest = new RestRequest("Turma", DataFormat.Json);
restRequest.AddJsonBody(model);
return(await this._client.PutAsync <ResponseApi <TurmaViewModel> >(restRequest));
}
public ActionResult Cadastrar()
{
var viewModel = new TurmaViewModel();
viewModel.Turmas = _unit.TurmaRepository.Listar();
return(View(viewModel));
}
public async Task IncluirAsync(TurmaViewModel model)
{
AddToken();
var resposta = await _httpClient.PostAsJsonAsync <TurmaViewModel>("v1/Turma", model);
resposta.EnsureSuccessStatusCode();
}
public ActionResult Novo()
{
var model = new TurmaViewModel();
model.Escolas = this.escolaBusiness.ListAll().ToList();
return(View(model));
}
public async Task <IActionResult> Create(TurmaViewModel turma)
{
var user = _userManager.GetUserAsync(User);
Turma create = new Turma
{
Professor = (Professor)await user,
DataCriacao = DateTime.Now,
MaxPonto = 1000,
AreaConhecimento = turma.AreaConhecimento,
Descricao = turma.Descricao,
ChaveAcesso = turma.ChaveAcesso,
Nome = turma.Nome
};
if (ModelState.IsValid)
{
_context.Add(create);
await _context.SaveChangesAsync();
LogUsuariosController log = new LogUsuariosController(_context);
await log.SetLog("Create Turma : " + turma.Nome, create.Professor.Id);
TempData["alert"] = $"{turma.Nome} foi criada";
return(RedirectToAction(nameof(IndexProfessor)));
}
return(View(turma));
}
public ActionResult Cadastrar(TurmaViewModel viewModel)
{
TurmaRepositorio turmaRepositorio = new TurmaRepositorio();
Turma mappedTurma = Mapper.Map <Turma>(viewModel);
if (viewModel.Id > 0)
{
turmaRepositorio.Atualizar(mappedTurma);
viewModel.ListaTurmas.ForEach((x) =>
{
if (x.Id == viewModel.Id)
{
x.Descricao = viewModel.Descricao;
x.LimiteAlunos = viewModel.LimiteAlunos;
}
});
}
else
{
viewModel.Id = turmaRepositorio.Inserir(mappedTurma);
viewModel.ListaTurmas.Add(viewModel);
}
return(View(viewModel));
}
private bool ValidateSave(TurmaViewModel formModel)
{
formModel.StatusOperation = true;
formModel.FieldsWithError.Clear();
var messageError = new List <String>();
if (String.IsNullOrEmpty(formModel.Codigo))
{
messageError.Add(String.Format(GlobalizationController.GetInstance().GetString("The field '{0}' is required."), GlobalizationController.GetInstance().GetString("Code")));
formModel.FieldsWithError.Add(nameof(formModel.Codigo));
}
if (String.IsNullOrEmpty(formModel.Professor))
{
messageError.Add(String.Format(GlobalizationController.GetInstance().GetString("The field '{0}' is required."), GlobalizationController.GetInstance().GetString("Teacher")));
formModel.FieldsWithError.Add(nameof(formModel.Professor));
}
if (!formModel.EscolaId.HasValue)
{
messageError.Add(String.Format(GlobalizationController.GetInstance().GetString("The field '{0}' is required."), GlobalizationController.GetInstance().GetString("School")));
formModel.FieldsWithError.Add(nameof(formModel.EscolaId));
}
if (messageError.Count > 0)
{
formModel.StatusMessage = string.Join("<br>", messageError);
formModel.StatusOperation = false;
}
return(formModel.StatusOperation);
}
// GET: Turma/Create
public async Task <IActionResult> Create()
{
var turmaViewModel = new TurmaViewModel();
ViewData["EscolaId"] = new SelectList(await this._escolaService.Listar(), "Id", "Nome", turmaViewModel.EscolaId);
ViewData["Turno"] = DataHelpers.Turnos(turmaViewModel.Turno);
return(View());
}
public TurmaViewModel AtualizarTurma(TurmaViewModel model)
{
BeginTransaction();
var turma = TurmaAdapter.ToDomainModel(model);
_turmaservice.AtualizarTurma(turma);
Commit();
return(model);
}
public void Save(TurmaViewModel formModel)
{
if (!this.ValidateSave(formModel))
{
return;
}
TurmaRepository.Save(formModel);
}
public ActionResult AtualizarTurma(TurmaViewModel model)
{
if (ModelState.IsValid)
{
_turmaappservice.AtualizarTurma(model);
string url = Url.Action("ListarTurma", "Turma", new { });
return(Json(new { success = true, url = url }));
}
return(PartialView("_AtualizarTurmas", model));
}
public ActionResult Lista(string nome)
{
var list = this.turmaBusiness.ListAllByNome(nome);
TurmaViewModel model = new TurmaViewModel();
model.Turmas = list.ToList();
return(View(model));
}
public static Turma ToDomainModel(TurmaViewModel model)
{
var turma = new Turma(
model.TurmaId,
model.DataTurma,
model.PeriodoTurma,
model.HorarioTurma,
model.ProfessorId);
return(turma);
}
public ConfigurationProfile()
{
Shared.Conversores.Configuracao.Registrar(this);
this.AllowNullCollections = true;
AlunoViewModel.Mapping(this);
DisciplinaViewModel.Mapping(this);
TurmaViewModel.Mapping(this);
TurmaAlunoViewModel.Mapping(this);
TurmaDisciplinaViewModel.Mapping(this);
}
public IActionResult Editar(TurmaViewModel viewModel)
{
var resultado = appService.Atualizar(viewModel);
if (resultado.Successo)
{
resultado.RedirecionarPara(Url.Action(nameof(Index)));
}
return(Json(resultado.Retorno()));
}
public async Task <ActionResult <TurmaViewModel> > Adicionar(TurmaViewModel turmaViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _turmaService.Adicionar(_mapper.Map <Turma>(turmaViewModel));
return(CustomResponse(turmaViewModel));
}
public async Task <IActionResult> Create([Bind("Nome,Descricao,Turno,EscolaId,Id,Cadastro,Atualizado")] TurmaViewModel turmaViewModel)
{
if (ModelState.IsValid)
{
var response = await this._turmaService.Adicionar(turmaViewModel);
return(RedirectToAction(nameof(Index)));
}
ViewData["EscolaId"] = new SelectList(await this._escolaService.Listar(), "Id", "Nome", turmaViewModel.EscolaId);
ViewData["Turno"] = DataHelpers.Turnos(turmaViewModel.Turno);
return(View(turmaViewModel));
}
public async Task Adicionar(TurmaViewModel turmaViewModel)
{
var turma = _mapper.Map <Turma>(turmaViewModel);
if (!ExecutarValidacao(new TurmaValidation(), turma))
{
return;
}
_turmaRepository.Adicionar(turma);
await _turmaRepository.UnitOfWork.Commit();
}
public ActionResult Save(TurmaViewModel formModel)
{
this.TurmaService.Save(formModel);
if (formModel.StatusOperation)
{
return(RedirectToAction("Index", "Turma"));
}
ViewBag.Escolas = EscolaRepository.GetAll().ToList();
ViewBag.ValidationFields = Json(new { formModel.StatusOperation, formModel.FieldsWithError, formModel.StatusMessage });
return(View("Detail", formModel));
}
//
// GET: /TurmaViewModels/Edit/5
public ActionResult EditarTurma(int id)
{
var dataAtual = DateTime.Today;
ViewBag.User = LoggedUser().Id;
var turma = BL.Turma.Get(a => a.IdTurma == id, null, "Matriz, Matriz.Modulo , Matriz.Modulo.Componente,AgendaComponente,ReprovacaoTurma").SingleOrDefault();
TurmaViewModel viewModel = TurmaViewModel.MapToViewModel(turma);
PopularListasTurmaVM(id, dataAtual, viewModel);
return(View(viewModel));
}
public IActionResult AtualizarEscola(TurmaViewModel escola)
{
try
{
var turmaEntity = _mapper.Map <Turma>(escola);
_turmaApplication.Atualizar(turmaEntity);
return(Ok("Turma atualizada com sucesso!"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult AdicionarTurma(TurmaViewModel turmaVm)
{
try
{
var escolaEntity = _mapper.Map <Turma>(turmaVm);
_turmaApplication.Adicionar(escolaEntity);
return(Ok(new StatusServer($"Turma {turmaVm.nome} adicionada com sucesso!")));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult EditarTurma(TurmaViewModel turmaviewmodel, FormCollection collection)
{
try
{
turmaviewmodel.PrecoView = turmaviewmodel.PrecoView == null ? "0" : turmaviewmodel.PrecoView;
turmaviewmodel.Preco = Decimal.Parse(turmaviewmodel.PrecoView.Replace("R$", "").Replace(".", ""));
turmaviewmodel.Aprovado = (!string.IsNullOrEmpty(Request.Form["aprovacaoTurma"])) ? Convert.ToUInt16(Request.Form["aprovacaoTurma"]) : new Nullable <int>();
turmaviewmodel.IdResponsavel = LoggedUser().Id;
if (turmaviewmodel.ReprovacaoTurma.Observacao == null && turmaviewmodel.Aprovado != 1)
{
turmaviewmodel.Aprovado = null;
}
if (turmaviewmodel.Aprovado == 0)
{
var usuario = BL.Usuario.Get(a => a.IdUsuario == turmaviewmodel.IdResponsavel).FirstOrDefault();
BL.Turma.AtualizarReprovacaoTurma(TurmaViewModel.MapToModel(turmaviewmodel), DateTime.Now, turmaviewmodel.ReprovacaoTurma.Observacao);
EmailHelper.DispararEmail(usuario.Nome, "Reprovação de Turma", usuario.Email, "", "A Turma foi reprovada pelo seguinte motivo: " + turmaviewmodel.ReprovacaoTurma.Observacao);
}
else if (turmaviewmodel.Aprovado == 1 && turmaviewmodel.ReprovacaoTurma.Observacao != null)
{
BL.Turma.AtualizarReprovacaoTurma(TurmaViewModel.MapToModel(turmaviewmodel), DateTime.Now, turmaviewmodel.ReprovacaoTurma.Observacao);
}
else if (turmaviewmodel.Aprovado == 1 && turmaviewmodel.ReprovacaoTurma.Observacao == null)
{
turmaviewmodel.Aprovado = null;
BL.Turma.AtualizarTurma(TurmaViewModel.MapToModel(turmaviewmodel));
}
else
{
BL.Turma.AtualizarTurma(TurmaViewModel.MapToModel(turmaviewmodel));
}
//BL.ReprovacaoTurma.AtualizarTurma(ReprovacaoTurmaViewModel.MapToModel(turmaviewmodel.ListaReprovacaoTurma.ToList()));
TempData["Sucesso"] = true;
TempData["SucessoMessage"] = "Cadastro da Turma" + turmaviewmodel.IdTurma.ToString("0000") + " foi atualizado com sucesso.";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = (ex.GetType().Name == "CustomException") ? ex.Message : "Erro ao Editar Turma";
PopularListasTurmaVM(turmaviewmodel.IdTurma, DateTime.Now, turmaviewmodel);
Logging.getInstance().Error(TempData["ErrorMessage"].ToString(), ex);
return(View(turmaviewmodel));
}
}
//
// GET: /TurmaViewModels/
public ViewResult Index(FiltrosTurma filtro = null)
{
try
{
var turmas = BL.Turma.Get(null, null, "MATRIZ, CR.MODALIDADE").ToList();
filtro.Turmas = TurmaViewModel.MapToListViewModel(turmas);
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página de turmas", ex);
}
return(View(filtro));
}
