public IActionResult Post(Habilidade novaHabilidade)
{
//faz a chamada para o metodo
_habilidadesRepository.Cadastrar(novaHabilidade);
return(StatusCode(201));
}
public void Deletar(int id)
{
Habilidade HabBuscada = ctx.Habilidades.Find(id);
ctx.Habilidades.Remove(HabBuscada);
ctx.SaveChanges();
}
public void Cadastrar(Habilidade cadastrarHabilidade)
{
context.Habilidades.Add(cadastrarHabilidade);
// Salva as informações para serem gravadas no banco de dados
context.SaveChanges();
}
public ActionResult Cadastrar(HabilidadeViewModel habilidadeViewModel)
{
if (ModelState.IsValid)
{
try
{
if (IsHabilidadeDuplicada(habilidadeViewModel))
{
habilidadeViewModel.Mensagem = "Já existe uma habilidade com este nome!";
return(View(habilidadeViewModel));
}
var habilidade = new Habilidade()
{
Nome = habilidadeViewModel.Nome
};
_unit.HabilidadeRepository.Cadastrar(habilidade);
_unit.Save();
}
catch (Exception e)
{
habilidadeViewModel.Mensagem = "Erro ao cadastrar habilidade: " + e.Message;
return(View(habilidadeViewModel));
}
}
else
{
return(View(habilidadeViewModel));
}
return(RedirectToAction("Listar"));
}
/// <summary>
/// Cadastra uma nova Habilidade
/// </summary>
/// <param name="novaHabilidade">Objeto novaClasse que sera cadastrado</param>
public void Cadastrar(Habilidade novaHabilidade)
{
//adicona a nova classe
ctx.Habilidades.Add(novaHabilidade);
//salva as informações inseridas no bd
ctx.SaveChanges();
}
public IHttpActionResult Delete([FromUri] int id)
{
try
{
if (id < 0)
{
return(BadRequest($"Identificador {id} inválido"));
}
Habilidade habilidadeEntity = _habilidadeService.Find(id);
if (habilidadeEntity == null)
{
return(NotFound());
}
_habilidadeService.Delete(habilidadeEntity);
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public IActionResult Put(int id, Habilidade habilidadeAtualizada)
{
Habilidade habilidadeBuscada = _habilidadeRepository.BuscarPorId(id);
//Verifica se habilidadeBuscada é diferente de nulo
if (habilidadeBuscada != null)
{
//Haverá uma tentativa de atualizar a clinica
try
{
//Caso seja, a habilidade será atualizada
_habilidadeRepository.Atualizar(id, habilidadeAtualizada);
//E retornará um statusCode Ok
return(StatusCode(200));
}
//Ao tentar atualizar, se não for possível, retornará um StatusCode com erro
catch (Exception erro)
{
return(BadRequest(erro));
}
}
// Se clinica não for diferente de nulo, retornará um StatusCode NotFound
return(StatusCode(404));
}
public async Task <IActionResult> Edit(int id, [Bind("Id, Descricao")] Habilidade habilidade)
{
if (id != habilidade.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try {
_db.Update(habilidade);
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) {
if (!HabilidadeExists(habilidade.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(habilidade));
}
/// <summary>
/// Aqui inserimos uma pessoa com várias Habilidades. No entando, adicionamos a pessoa ao contexto e em seguinda as habilidades.
/// </summary>
private static void InsertPessoaComHabilidades()
{
using (var context = new AnacAulaContext())
{
var pessoa = new Pessoa
{
Nome = "Fulano de tal",
DataNascimento = new DateTime(1987, 12, 16),
DocumentoOficial = "15454",
PerfilId = 1
};
var habilidade = new Habilidade
{
Descricao = "Atirar",
TipoHabilidade = TipoHabilidade.Atirar
};
var habilidade1 = new Habilidade
{
Descricao = "Condificar",
TipoHabilidade = TipoHabilidade.Codificar
};
context.Pessoas.Add(pessoa);
pessoa.Habilidades.Add(habilidade1);
pessoa.Habilidades.Add(habilidade);
context.SaveChanges();
}
}
public async Task <IActionResult> Put(int id, [FromBody] Habilidade habilidade)
{
try
{
if (habilidade.Id != id)
{
throw new Exception("Operação não pode ser realizada.");
}
var _habilidade = await habilidadeRepo.Select(id);
if (_habilidade.Id == 0)
{
return(NotFound(new Messages("Esta habilidade não existe ou já foi removido.")));
}
await habilidadeRepo.Update(habilidade);
return(StatusCode(StatusCodes.Status200OK));
}
catch (Exception ex)
{
return(StatusCode(500, new Messages(ex.Message)));
}
}
public void Cadastrar(Habilidade novaHabilidade)
{
//Adiciona uma nova habilidade
ctx.Habilidades.Add(novaHabilidade);
// Para adicionar informações ao banco sempre utilizar o SaveChanges para salvar essas alterações
ctx.SaveChanges();
}
public void Delete(int id)
{
Habilidade skillSought = ctx.Habilidades.Find(id);
ctx.Habilidades.Remove(skillSought);
ctx.SaveChanges();
}
public NotificationResult Salvar(Habilidade entidade)
{
var notificationResult = new NotificationResult();
try
{
if (entidade.CodHabilidade == 0)
{
notificationResult.Add(new NotificationError("Qtde. de produtos no Estoque inválido.", NotificationErrorType.USER));
}
if (notificationResult.IsValid)
{
_habilidade_Repositorio.Adicionar(entidade);
notificationResult.Add("Produto cadastrado com sucesso.");
}
notificationResult.Result = entidade;
return(notificationResult);
}
catch (Exception ex)
{
return(notificationResult.Add(new NotificationError(ex.Message)));
}
}
/// <summary>
/// Metodo para utilizar uma habilidade selecionada no combobox do jogador
/// </summary>
private void Btn_Habilidade(object sender, RoutedEventArgs e)
{
if (ListaH.SelectedValue != null)
{
Habilidade hbl = ListaH.SelectedItem as Habilidade;
//verificar se o usuario tem a energia para usar a habilidade
if (jogador.UsarHabilidade(hbl))
{
//armazena os buffes para tirar no fim da rodada
contAnimo += hbl.BuffAnimo;
contPersistencia += hbl.BuffPersistencia;
if (hbl.Dano > 0)
{
//ataque do jogador
int dano = jogador.Atacar(monstro, null, hbl);
//exibir marcador de dano do monstro
_ = ExibeDanoCombateAsync(dano, 1);
}
//habilidade de passar a vez
if (!hbl.DesativaHabilidade)
{
InteligenciaMonstro();
}
}
else
{
Mensagem("Você não possui energia o suficiente para usar a habilidade", "Aviso");
}
AtualizarTexto();
checkLife();
}
}
public async Task <FuncionarioModel> GetFuncionarioById(int id)
{
var funcionario = _mapper.Map <FuncionarioModel>(await Funcionario.FindAsync(id));
if (funcionario == null)
{
throw new EntityNotFoundException("Entidade não encontrada!");
}
var habilidadesList = new List <HabilidadeModel>();
var funcionarioHabilidades = await FuncionarioHabilidade.ToListAsync();
var funcionarioHabilidadeFiltrado = funcionarioHabilidades.Where(x => x.Funcionario != null && x.Funcionario.Id == id).ToList();
var habilidades = await Habilidade.ToListAsync();
foreach (var item in funcionarioHabilidadeFiltrado)
{
var filtro = _mapper.Map <HabilidadeModel>(habilidades.Where(x => x.Id == item.Habilidade.Id).FirstOrDefault());
habilidadesList.Add(filtro);
}
funcionario.Habilidades = habilidadesList;
return(funcionario);
}
public Habilidade Patch(int id, Habilidade habilidade)
{
try
{
using (HttpClient client = HttpContext.GetHttpClient())
{
string jsonData = JsonConvert.SerializeObject(habilidade);
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod("PATCH"), APIConfigurations.UrlHabilidade(id))
{
Content = new StringContent(jsonData, Encoding.UTF8, "application/json")
};
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <Habilidade>(response.Content.ReadAsStringAsync().Result));
}
}
}
throw new Exception($"Ocorreu um erro ao atualizar a habilidade com ID {id}.");
}
catch (Exception ex)
{
throw ex;
}
}
public IHttpActionResult Patch([FromUri] int id, [FromBody] Delta <Habilidade> habilidade)
{
try
{
if (id < 0)
{
return(BadRequest($"Identificador {id} inválido"));
}
Habilidade habilidadeEntity = _habilidadeService.Find(id);
if (habilidadeEntity == null)
{
return(NotFound());
}
habilidade.Patch(habilidadeEntity);
_habilidadeService.Edit(habilidadeEntity);
return(Ok(HabilidadeHelpers.DePara(habilidadeEntity)));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <FuncionarioModel> UpdateFuncionario(FuncionarioModel funcionarioModel)
{
var funcionarioDataModel = await Funcionario.FindAsync(funcionarioModel.Id);
if (funcionarioDataModel != null)
{
Entry(funcionarioDataModel).State = EntityState.Detached;
funcionarioDataModel = _mapper.Map <FuncionarioDataModel>(funcionarioModel);
Funcionario.Update(funcionarioDataModel);
var funcionarioHabiliade = await FuncionarioHabilidade.ToListAsync();
var funcionarioHabiliadeFiltrado = funcionarioHabiliade.Where(x => x.Funcionario != null && x.Funcionario.Id == funcionarioDataModel.Id);
FuncionarioHabilidade.RemoveRange(funcionarioHabiliadeFiltrado);
foreach (var e in funcionarioModel.Habilidades)
{
var habilidadeDataModel = await Habilidade.FindAsync(e.Id);
AdicionarFuncionarioHabilidade(funcionarioDataModel, habilidadeDataModel);
}
await SaveChangesAsync();
return(funcionarioModel);
}
else
{
throw new EntityNotFoundException("Entidade não encontrada!");
}
}
public async Task <IActionResult> PutHabilidade([FromRoute] int id, [FromForm] Habilidade habilidade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != habilidade.Id)
{
return(BadRequest());
}
_context.Entry(habilidade).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HabilidadeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> AddPersonagemHabilidadeAsync(PersonagemHabilidade novoPersonagemHabilidade)
{
Personagem personagem = await _context.Personagens
.Include(p => p.Arma)
.Include(p => p.PersonagemHabilidades).ThenInclude(ps => ps.Habilidade)
.FirstOrDefaultAsync(p => p.Id == novoPersonagemHabilidade.PersonagemId &&
p.Usuario.Id == ObterUsuarioId());
if (personagem == null)
{
return(BadRequest("Personagem não encontrado para o usuário em questão"));
}
Habilidade habilidade = await _context.Habilidades
.FirstOrDefaultAsync(s => s.Id == novoPersonagemHabilidade.HabilidadeId);
if (habilidade == null)
{
BadRequest("Habilidade não encontrada");
}
PersonagemHabilidade ph = new PersonagemHabilidade();
ph.Personagem = personagem;
ph.Habilidade = habilidade;
await _context.PersonagemHabilidades.AddAsync(ph);
await _context.SaveChangesAsync();
return(Ok(ph));
}
public IActionResult Put(int id, Habilidade habilidadeUpdate)
{
// chama o método
_habilidadeRepository.Atualizar(id, habilidadeUpdate);
return(StatusCode(204));
}
public void TesteGeraHabilidade()
{
GeradorHabilidade gerador = new GeradorHabilidade();
Habilidade habilidade = gerador.Gerar(rnd);
Assert.IsNotNull(habilidade);
}
public IActionResult Post(Habilidade novaHabilidade)
{
//Chamada para o método
_HabilidadeRepository.Cadastrar(novaHabilidade);
//retorna created
return(StatusCode(201));
}
public async Task <ActionResult> Edit([Bind(Include = "cedula_empleadoFK,categoriaPK,descripcionPK")] Habilidade habilidad)
{
if (ModelState.IsValid)
{
var sql =
from a in db.Habilidades
where a.cedula_empleadoFK == cedulaEdit &&
a.descripcionPK == descripcionEdit &&
a.categoriaPK == categoriaEdit
select a;
foreach (var a in sql)
{
db.Habilidades.Remove(a);
break;
}
try
{
await db.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
// Provide for exceptions.
}
db.Habilidades.Add(habilidad);
await db.SaveChangesAsync();
return(RedirectToAction("Index", new { cedula_empleadoFK = habilidad.cedula_empleadoFK }));
}
ViewBag.cedula_empleadoFK = new SelectList(db.Empleadoes, "cedulaPK", "nombreP", habilidad.cedula_empleadoFK);
return(View(habilidad));
}
/// <summary>
/// Cadastra uma nova habilidade
/// </summary>
/// <param name="novaHabilidade">Objeto novaHabilidade que será cadastrada</param>
public void Cadastrar(Habilidade novaHabilidade)
{
//Adiciona uma nova habilidade
ctx.Habilidades.Add(novaHabilidade);
//Salva as informações para serem gravadas no banco de dados
ctx.SaveChanges();
}
public void Deletar(int id)
{
Habilidade habilidadeBuscado = _context.Habilidades.Find(id);
_context.Habilidades.Remove(habilidadeBuscado);
_context.SaveChanges();
}
/// <summary>
/// Cadastra uma nova habilidade
/// </summary>
/// <param name="novaHabilidade">objeto que sera cadastrado</param>
public void Cadastrar(Habilidade novaHabilidade)
{
// Adiciona este novaHabilidade
contex.Habilidades.Add(novaHabilidade);
// Salva as infiormacoes para serem gravadas no banco de dados
contex.SaveChanges();
}
public void ComprarHabilidade(Habilidade habilidade)
{
if (pontos >= habilidade.GetCusto())
{
pontos -= habilidade.GetCusto();
habilidadesPossuidas.Add(habilidade);
}
}
public ActionResult RemoveHability(string id, string category, string description)
{
Habilidade habilidad = db.Habilidades.Find(id, category, description);
db.Habilidades.Remove(habilidad);
db.SaveChanges();
return(RedirectToAction("Index", new { cedula_empleadoFK = habilidad.cedula_empleadoFK }));
}
public IActionResult Put(int id, Habilidade HabilidadeAtualizada)
{
//Faz a chamada para o método
_habilidadeRepository.Atualizar(id, HabilidadeAtualizada);
//retorna um status code
return(StatusCode(204));
}
public Atributos(int forca, int agilidade, int habilidade, int resistencia, int armadura, float distanciaDeAtaque, float velocidadeDeMovimento, Habilidade habilidadePrimaria, Habilidade habilidadeSecundaria)
{
this.forca = forca;
this.agilidade = agilidade;
this.habilidade = habilidade;
this.resistencia = resistencia;
this.armadura = armadura;
this.distanciaDeAtaque = distanciaDeAtaque;
this.habilidadePrimaria = habilidadePrimaria;
this.habilidadeSecundaria = habilidadeSecundaria;
this.velocidadeDeMovimento = velocidadeDeMovimento;
vida = vidaTotal = (resistencia * 10) + (50 - resistencia);
energia = energiaTotal = (habilidade * 5) + (resistencia * 2);
velocidadeDeAtaque = 1 + (15/agilidade);
regeneracaoDeVida = (int) ((resistencia + habilidade)/2);
regeneracaoDeEnergia = (int) ((resistencia + habilidade*2)/3);
}
