public ActionResult Editar(int?id)
{
if (id == null)
{
return(new BadRequestResult());
}
Atividade atividade = context.TBAtividades.Find(id);
if (atividade == null)
{
return(NotFound("Atividade não foi encontrado!"));
}
TipoAtividade tipoAtividade = context.TBTiposAtividades.Find(atividade.idTipoAtiv);
if (tipoAtividade == null)
{
tipoAtividade = new TipoAtividade();
tipoAtividade.NomeAtividade = "Erro 404 - Essa atividade foi deletada ou perdida.";
}
AtividadeLink atividadeLink = new AtividadeLink();
atividadeLink.atividade = atividade;
atividadeLink.tipoAtividade = tipoAtividade;
TempData["id"] = atividade.idUsuario;
atividadeLink.tipoAtividades = context.TBTiposAtividades.ToList();
return(PartialView(atividadeLink));
}
public IHttpActionResult PostTipoAtividade(TipoAtividade tipoatividade)
{
TipoAtividade novoTipoAtividade = _tipoatividadeBll.AddTipoAtividade(tipoatividade);
if (novoTipoAtividade == null)
return NotFound();
return Ok(novoTipoAtividade);
}
public ActionResult DeleteConfirmed(int id)
{
TipoAtividade tipoAtividade = db.TipoAtividadeSet.Find(id);
db.TipoAtividadeSet.Remove(tipoAtividade);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Atividade(Guid id, string nome, TipoAtividade tipoAtividade, Aparelho aparelho, string descricao)
{
Id = id;
Nome = nome;
TipoAtividade = tipoAtividade;
Aparelho = aparelho;
Descricao = descricao;
}
public CheckListAtividadeTipoAtividade ToEntity()
{
return(new CheckListAtividadeTipoAtividade
{
TipoAtividade = TipoAtividade?.ToEntity(),
CheckListAtividade = CheckListAtividade
});
}
public void Deve_criar_uma_atividade_com_tipo(TipoAtividade tipo)
{
//When
var ativdade = new Atividade("titulo", descricao, tipo, data);
//Then
Assert.Equal(tipo, ativdade.Tipo);
}
public ActionResult Edit([Bind(Include = "Id,nome")] TipoAtividade tipoAtividade)
{
if (ModelState.IsValid)
{
db.Entry(tipoAtividade).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoAtividade));
}
public void Deve_criar_atividade_na_sexta_feita_apos_as_13h(TipoAtividade tipoEsperado)
{
//Given
var dataInvalida = new DateTime(2018, 11, 30, 14, 00, 00);
//When
var atividade = new Atividade(titulo, descricao, tipoEsperado, dataInvalida);
//Then
Assert.Equal(tipoEsperado, atividade.Tipo);
}
public Atividade(string titulo, string descricao, TipoAtividade tipo, DateTime dataCriacao)
{
DomainException.Quando(string.IsNullOrWhiteSpace(titulo),
"Não é permitido criar atividade com titulo inválido");
DomainException.Quando(tipo == TipoAtividade.ManutencaoUrgente && dataCriacao.Date.DayOfWeek == DayOfWeek.Friday && dataCriacao.Hour >= 13,
"Não pode criar atividade do tipo manutenção urgente após as 13h da sexta-feira");
Titulo = titulo;
Descricao = descricao;
Tipo = tipo;
}
public ActionResult Create([Bind(Include = "Id,nome")] TipoAtividade tipoAtividade)
{
if (ModelState.IsValid)
{
db.TipoAtividadeSet.Add(tipoAtividade);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoAtividade));
}
public static TipoAtividade MapToModel(TipoAtividadeViewModel TipoAtividadeViewModel)
{
TipoAtividade TipoAtividade = new TipoAtividade()
{
IdTipoAtividade = TipoAtividadeViewModel.IdTipoAtividade,
Nome = TipoAtividadeViewModel.Nome,
Interna = TipoAtividadeViewModel.Interna,
AgendaDocente = TipoAtividadeViewModel.AgendaDocente
};
return(TipoAtividade);
}
public static TipoAtividadeViewModel MapToViewModel(TipoAtividade TipoAtividade)
{
TipoAtividadeViewModel TipoAtividadeViewModel = new TipoAtividadeViewModel()
{
IdTipoAtividade = TipoAtividade.IdTipoAtividade,
Nome = TipoAtividade.Nome,
Interna = TipoAtividade.Interna,
AgendaDocente = TipoAtividade.AgendaDocente
};
return(TipoAtividadeViewModel);
}
public TipoAtividade ToEntity()
{
var entidade = new TipoAtividade
{
Id = Id,
Descricao = Descricao,
DataInsercao = this.DataInsercao < System.Data.SqlTypes.SqlDateTime.MinValue.Value ? DateTime.Now : this.DataInsercao,
Ativo = Ativo
};
return(entidade);
}
public ActionResult AtividadeDataDeValidade(string buscar)
{
Models.AtividadeLink atividadesLink = new Models.AtividadeLink();
List <Atividade> atividades = new List <Atividade>();
atividadesLink.tipoAtividades = context.TBTiposAtividades.ToList();
if (buscar == null)
{
foreach (Atividade atividade in context.TBAtividades.ToList())
{
if (atividade.DataValidade != null)
{
atividades.Add(atividade);
}
}
atividadesLink.atividades = atividades;
}
else
{
foreach (Models.Atividade atividade in context.TBAtividades.ToList())
{
TipoAtividade tipo = context.TBTiposAtividades.Find(atividade.idTipoAtiv);
if (atividade.DataValidade != null)
{
if (atividade.nome.Contains(buscar) || atividade.dataInicio.ToShortDateString().Contains(buscar) ||
atividade.dataFim.ToShortDateString().Contains(buscar) || tipo.NomeAtividade.Contains(buscar))
{
atividades.Add(atividade);
}
}
atividadesLink.atividades = atividades;
atividadesLink.tipoAtividades = context.TBTiposAtividades.ToList();
}
}
Usuario usuario = null;
try
{
var sid = int.Parse(User.Claims.Where(c => c.Type == ClaimTypes.Sid).Select(c => c.Value).SingleOrDefault());
usuario = context.TBUsuario.FirstOrDefault(x => x.ID == sid);
TempData["id"] = usuario.ID;
TempData["nome"] = usuario.nome;
}
catch
{
TempData["erro"] = "Usuario não encontrado!";
}
return(View(atividadesLink));
}
public void Nao_deve_concluir_atividade_com_quantidade_invalida_de_caracter(TipoAtividade tipo)
{
//Given
const string mensagemEsperada = "Quantidade de caracteres inferior a 50";
var atividade = new Atividade(titulo, descricao, tipo, data);
//When
Action act = () => atividade.Concluir();
//Then
var erro = Assert.Throws <DomainException>(act);
Assert.Equal(mensagemEsperada, erro.Message);
Assert.False(atividade.Concluida);
}
public void Deve_marcar_atividade_como_concluida(TipoAtividade tipo)
{
//Given
const string descricaoValida = @"Lorem Ipsum is simply dummy text of the printing and typesetting industry.
Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley.";
var atividade = new Atividade(titulo, descricaoValida, tipo, data);
//When
atividade.Concluir();
//Then
Assert.True(atividade.Concluida);
}
// GET: TipoAtividades/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoAtividade tipoAtividade = db.TipoAtividadeSet.Find(id);
if (tipoAtividade == null)
{
return(HttpNotFound());
}
return(View(tipoAtividade));
}
public void Deve_salvar_uma_atividade()
{
//Given
const string titulo = "Apenas mais um titulo";
const string descricao = "Essa é uma descricao para um teste.";
TipoAtividade tipoAtividade = TipoAtividade.Desenvolvimento;
//When
_service.AdicionarAtividade(titulo, descricao, tipoAtividade);
//Then
_repository.Verify(r => r.Adicionar(It.Is <Atividade>(atividade =>
atividade.Titulo == titulo &&
atividade.Descricao == descricao &&
atividade.Tipo == tipoAtividade)), Times.Once);
}
public TipoAtividade Adicionar(TipoAtividade obj)
{
if (!obj.IsValid())
{
return(obj);
}
obj.ValidationResult = new TipoAtividadeValidation().Validate(obj);
if (!obj.ValidationResult.IsValid)
{
return(obj);
}
obj.ValidationResult.Message = Mensagens.MS_003;
return(_classRepository.Adicionar(obj));
}
public TipoAtividade AddTipoAtividade(TipoAtividade tipoatividade)
{
using (TimeSContext db = new TimeSContext())
{
try
{
db.TiposAtividades.Add(tipoatividade);
db.SaveChanges();
return tipoatividade;
}
catch (Exception ex)
{
Debug.Write(ex.Message);
return null;
}
}
}
public TipoAtividade EditarTipoAtividade(TipoAtividade tipoatividade)
{
using (TimeSContext db = new TimeSContext())
{
try
{
db.Entry(tipoatividade).State = EntityState.Modified;
db.SaveChanges();
return tipoatividade;
}
catch (Exception ex)
{
Debug.Write(ex.Message);
return null;
}
}
}
public Int32 ObterQuantidade(TipoAtividade tipoAtividade)
{
switch (tipoAtividade)
{
case TipoAtividade.Acesso:
return(QuantidadePorAcesso);
case TipoAtividade.AcompanhamentoOnLine:
return(QuantidadePorAcompanhamentoOnLine);
case TipoAtividade.AcompanhamentoPresencial:
return(QuantidadePorAcompanhamentoPresencial);
default:
return(1);
}
}
public void Alterar(string titulo, string descricao, TipoAtividade tipo, DateTime data)
{
var ehTipoManutencaoUrgente = tipo == TipoAtividade.ManutencaoUrgente;
var horarioInvalido = data.Date.DayOfWeek == DayOfWeek.Friday && data.Hour >= 13;
DomainException.Quando(ehTipoManutencaoUrgente && horarioInvalido,
"Não pode alterar atividade para manutenção urgente após as 13h da sexta-feira");
if (!string.IsNullOrEmpty(titulo))
{
Titulo = titulo;
}
if (!string.IsNullOrEmpty(descricao))
{
Descricao = descricao;
}
Tipo = tipo;
}
public ActionResult TiposEditar(int?id)
{
if (id == null)
{
return(new BadRequestResult());
}
TipoAtividade atividade = context.TBTiposAtividades.Find(id);
if (atividade == null)
{
return(NotFound("Atividade não foi encontrado!"));
}
AtividadeLink atividadeLink = new AtividadeLink();
atividadeLink.tipoAtividade = atividade;
TempData["id"] = atividade.idUsuario;
return(PartialView(atividadeLink));
}
public ActionResult TiposDetalhes(int?id)
{
if (id == null)
{
return(new BadRequestResult());
}
TipoAtividade tipoAtividade = context.TBTiposAtividades.Find(id);
if (tipoAtividade == null)
{
return(NotFound("Tipo Atividade não foi encontrado!"));
}
List <Atividade> atividades = new List <Atividade>();
try
{
foreach (Atividade atividade in context.TBAtividades.ToList())
{
if (atividade.idTipoAtiv == tipoAtividade.ID)
{
atividades.Add(atividade);
}
}
}
catch
{
return(BadRequest("Não foi possível acessar as atividades"));
}
Usuario usuario;
var sid = int.Parse(User.Claims.Where(c => c.Type == ClaimTypes.Sid).Select(c => c.Value).SingleOrDefault());
usuario = context.TBUsuario.FirstOrDefault(x => x.ID == sid);
TempData["id"] = usuario.ID;
TempData["nome"] = usuario.nome;
AtividadeLink atividadeLink = new AtividadeLink();
atividadeLink.tipoAtividade = tipoAtividade;
atividadeLink.atividades = atividades;
return(PartialView(atividadeLink));
}
public void Deve_excluir_uma_atividade()
{
//Given
const string titulo = "Outro titulo";
const int id = 323;
TipoAtividade tipoAtividade = TipoAtividade.Manutencao;
var atividadeEsperada = AtividadeBuilder.Novo()
.ComTitulo(titulo)
.ComTipoAtividade(tipoAtividade)
.ComId(id).Build();
_repository.Setup(r => r.ObterPorId(id)).Returns(atividadeEsperada);
//When
_service.RemoverAtividade(id);
//Then
_repository.Verify(r => r.Remover(It.Is <Atividade>(atividade =>
atividade.Titulo == titulo &&
atividade.Id == id)), Times.Once);
}
public void Nao_Deve_excluir_uma_atividade()
{
//Given
const string titulo = "Outro titulo";
const int id = 323;
TipoAtividade tipoAtividade = TipoAtividade.ManutencaoUrgente;
var atividadeEsperada = AtividadeBuilder.Novo()
.ComTitulo(titulo)
.ComTipoAtividade(tipoAtividade)
.ComId(id).Build();
_repository.Setup(r => r.ObterPorId(id)).Returns(atividadeEsperada);
//When
Action act = () => _service.RemoverAtividade(id);
//Then
Assert.Throws <DomainException>(act);
_repository.Verify(r => r.Remover(It.Is <Atividade>(atividade =>
atividade.Titulo == titulo && atividade.Id == id)), Times.Never);
}
private TipoAtividade ConfigurarTipoAtividade(AtividadeViewModel atividadeViewModel, Atividade atividade)
{
TipoAtividade tipoAtividade = new TipoAtividade();
foreach (var tipo in atividadeViewModel.Tipos)
{
if (tipo.Excluir)
{
tipoAtividade = _tipoatividadeService.ObterPorId(tipo.IdTipoAtividade);
_tipoatividadeService.Remover(tipoAtividade);
}
else
{
tipoAtividade = Mapper.Map <TipoAtividadeViewModel, TipoAtividade>(tipo);
tipoAtividade.IdAtividade = atividadeViewModel.IdAtividade;
if (tipoAtividade.Faixa == null)
{
tipoAtividade.Faixa = "";
}
if (tipo.IdTipoAtividade == 0)
{
_tipoatividadeService.Adicionar(tipoAtividade);
}
else
{
_tipoatividadeService.Atualizar(tipoAtividade);
}
if (!tipoAtividade.ValidationResult.IsValid)
{
break;
}
atividade.Tipos.Add(tipoAtividade);
}
}
return(tipoAtividade);
}
public async Task <ActionResult> Edit([Bind(Include = "Id, Nome, Administrativo")] TipoAtividade tipoAtividade)
{
if (ModelState.IsValid)
{
try
{
db.Entry(tipoAtividade).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(tipoAtividade));
}
public ActionResult Detalhes(int?id)
{
if (id == null)
{
return(new BadRequestResult());
}
Atividade atividade = context.TBAtividades.Find(id);
TipoAtividade tipoAtividade = context.TBTiposAtividades.Find(atividade.idTipoAtiv);
if (atividade == null)
{
return(NotFound("Atividade não foi encontrado!"));
}
if (tipoAtividade == null)
{
tipoAtividade = new TipoAtividade(); tipoAtividade.NomeAtividade = "Esse tipo atividade foi excluido!";
}
AtividadeLink atividadeLink = new AtividadeLink();
atividadeLink.atividade = atividade;
atividadeLink.tipoAtividade = tipoAtividade;
return(PartialView(atividadeLink));
}
public AtividadeViewModel Atualizar(AtividadeViewModel atividadeViewModel)
{
TratarTiposAtividadeExcluidos(atividadeViewModel);
var atividade = Mapper.Map <AtividadeViewModel, Atividade>(atividadeViewModel);
atividade.ValidationResult = new AtividadeValidation().Validate(atividade);
if (!atividade.ValidationResult.IsValid)
{
atividadeViewModel.ValidationResult = atividade.ValidationResult;
return(atividadeViewModel);
}
BeginTransaction();
atividade = new Atividade {
IdAtividade = atividadeViewModel.IdAtividade, NomAtividade = atividadeViewModel.NomAtividade, PctMinimoReducao = atividadeViewModel.PctMinimoReducao, Link = atividadeViewModel.Link, Tipos = new List <TipoAtividade>()
};
TipoAtividade tipoAtividade = ConfigurarTipoAtividade(atividadeViewModel, atividade);
//Se ocorreu erro no tipo atividade, retornar
if (!tipoAtividade.ValidationResult.IsValid)
{
atividadeViewModel.ValidationResult = tipoAtividade.ValidationResult;
return(atividadeViewModel);
}
var atividadeReturn = _atividadeService.Atualizar(atividade);
if (atividadeReturn.ValidationResult.IsValid)
{
_logService.Logar(atividade, atividadeViewModel.Usuario.CPF, Domain.Enums.Operacao.Alteração.ToString());
Commit();
}
atividadeViewModel = Mapper.Map <Atividade, AtividadeViewModel>(atividadeReturn);
return(atividadeViewModel);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TipoAtividade tipoAtividade = await db.TiposAtividade.FindAsync(id);
if (tipoAtividade != null)
{
if (await db.Atividades.AnyAsync(x => x.TipoAtividade.Id == tipoAtividade.Id))
{
MensagemParaUsuarioViewModel.MensagemAlerta("Essa ação não pode ser excluída porque já tem perfis associados a ela.", TempData);
return(RedirectToAction("Index"));
}
try
{
db.Entry(tipoAtividade).State = EntityState.Deleted;
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Tipo de Atividade não econtrado.", TempData, ModelState);
}
return(View(tipoAtividade));
}
public IHttpActionResult PutTipoAtividade(TipoAtividade tipoatividade)
{
if (_tipoatividadeBll.EditarTipoAtividade(tipoatividade) == null)
return NotFound();
return Ok(tipoatividade);
}
public TipoAtividade EditarTipoAtividade(TipoAtividade tipoatividade)
{
return _tipoatividadeDal.EditarTipoAtividade(tipoatividade);
}
public TipoAtividade AddTipoAtividade(TipoAtividade tipoatividade)
{
return _tipoatividadeDal.AddTipoAtividade(tipoatividade);
}
public AtividadeBuilder ComTipoAtividade(TipoAtividade tipo)
{
Tipo = tipo;
return(this);
}
