// GET: Agentes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
return(RedirectToAction("Index"));
}
Agentes agentes = db.Agentes.Find(id);
if (agentes == null)
{
//return HttpNotFound();
return(RedirectToAction("Index"));
}
return(View(agentes));
}
// GET: Agentes/Edit/5
/// <summary>
/// apresentar na View os dados de um agente,
/// para eventual edição
/// </summary>
/// <param name="id"> identifica o agente a editar</param>
/// <returns>view</returns>
public ActionResult Edit(int?id)
{
// se se escrever 'int?' é possível
// não fornecer o valor para o ID e não há erro
// proteção para o caso de não ter sido fornecido um ID válido
if (id == null)
{
// instrução original
// devolve um erro qd não há ID
// logo, não é possível pesquisar por um Agente
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
// procura na BD, o Agente cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
// proteção para o caso de não ter sido encontrado qq Agente
// que tenha o ID fornecido
if (agente == null)
{
// o agente não foi encontrado
// logo, gera-se uma msg de erro
// return HttpNotFound();
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
// existe Agente
// contudo, será que posso editá-lo?
if (User.IsInRole("GestaoDePessoal") ||
User.Identity.Name.Equals(agente.UserName))
{
// entrega à View os dados do Agente encontrado
return(View(agente));
}
else
{
// não há permissão para editar o Agente
return(RedirectToAction("Index"));
}
}
public ActionResult DeleteNewMethod(int id)
{
Agentes agente = db.Agentes.Find(id);
try
{
db.Agentes.Remove(agente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("aconteceu um erro com a eliminação do Agente '{0}', porque há multas associadas a ele.", agente.Nome));
}
// se aqui chego, é pq alguma coisa correu mal
return(View(agente));
}
public ActionResult DeleteConfirmed(int id)
{
Agentes agente = db.Agentes.Find(id);
try
{
db.Agentes.Remove(agente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception)
{
ModelState.AddModelError("", string.Format("A coisa correu mal na eliminação do Agente '{0}', existem multas associadas a ele", agente.Nome));
}
//Se o fluxo passar por aqui é porque alguma coisa correu mal
return(View(agente));
}
public IHttpActionResult GetAgentes(int id)
{
Agentes agentes = db.Agentes.Find(id);
if (agentes == null)
{
return(NotFound());
}
// Nota: Cuidado que aqui também pode ocorrer o problema das referências
// circulares! Fica como exercício para casa...
// Não precisam do Select aqui (Linq é só para listas),
// por isso seria algo como
// var resultado = new { ??? };
return(Ok(agentes));
}
// GET: Agentes/Delete/5
/// <summary>
/// mostra na view os dados de um agente para porterior, eventual, remoção
/// </summary>
/// <param name="id">identificador do agente a remover</param>
/// <returns></returns>
public ActionResult Delete(int?id)
{
// o ID do agente não foi fornecido
// não é possível procurar o Agente
// o que devo fazer?
if (id == null)
{
/// opção por defeito do 'template'
/// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
/// e não há ID do Agente, uma de duas coisas aconteceu:
/// - há um erro nos links da aplicação
/// - há um 'chico experto' a fazer asneiras no URL
/// redireciono o utilzador para o ecrã incial
return(RedirectToAction("Index"));
}
// procura os dados do Agentes, cujo ID é fornecido
Agentes agente = db.Agentes.Find(id);
/// se o agente não fôr encontrado
if (agente == null)
{
// ou há um erro,
// ou há um 'chico experto'...
// return HttpNotFound();
/// redireciono o utilzador para o ecrã incial
return(RedirectToAction("Index"));
}
/// para o caso do utilizador alterar, de forma fraudulenta,
/// os dados do Agente, vamos guardá-los internamente
/// Para isso, vou guardar o valor do ID do Agente
/// - guardar o ID do Agente num cookie cifrado
/// - guardar o ID numa var. de sessão
/// (quem estiver a usar o Asp .Net Core já não tem esta ferramenta...)
/// - outras opções...
Session["IdAgente"] = agente.ID;
Session["Metodo"] = "Agentes/Delete";
// envia para a View os dados do Agente encontrado
return(View(agente));
}
// GET: Agentes/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
Agentes agente = db.Agentes.Find(id);
if (agente == null)
{
return(RedirectToAction("Index"));
}
Session["Metodo"] = "";
return(View(agente));
}
public ActionResult Create([Bind(Include = "ID,Nome,Esquadra,Fotografia")] Agentes agentes)
{
//escrever os dados de um novo Agente na BD;
// ModelState.IsValid -> Confronta od dados fornecidos da View com as exigências do Modelo
if (ModelState.IsValid)
{
// adiciona o novo Agente à BD
db.Agentes.Add(agentes);
// faz 'Commit' às Alterações
db.SaveChanges();
// se tudo correr bem, redireciona para a página do Index;
return(RedirectToAction("Index"));
}
// se houver erro, reapresenta os dados do Agente na View;
return(View(agentes));
}
public ActionResult DeleteConfirmed(int id)
{
Agentes agente = db.Agentes.Find(id);
try
{
db.Agentes.Remove(agente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception)
{
//gerar uma mensagem de erro, a ser apresentada ao utilizador
ModelState.AddModelError("", string.Format("Não foi possivel remover o agente '{0}', porque existem {1} multas associadas a ele", agente.Nome, agente.ListaDeMultas.Count));
}
//reenviar os dados para a View
return(View(agente));
}
// GET: Agentes/Delete/5
/// <summary>
/// apresenta na view os dados de um agente
/// com vista a sua eventual eliminacao
/// </summary>
/// <param name="id">identificador do agente</param>
/// <returns></returns>
public ActionResult Delete(int?id)
{
//verifica se o ID fornecido é válido
if (id == null)
{
return(RedirectToAction("Index"));
}
//pesquisa pelo agente cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
// verifica se o agente foi encontrado
if (agente == null)
{
// agente nao existe redirecciona para a pagina inicial
return(RedirectToAction("Index"));
}
return(View(agente));
}
// GET: Agentes/Delete/5
/// <summary>
/// apresenta na view os dados de um agente, com vista à sua, eventual, eliminação
/// </summary>
/// <param name="id">identificador do agente</param>
/// <returns></returns>
public ActionResult Delete(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
//pesquisar pelo agentente, cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
//verificar se o agente foi encontrado
if (agente == null)
{
//o agente nao existe
// redirecionar para a pagina tual
return(RedirectToAction("Index"));
}
return(View(agente));
}
public ActionResult DeleteConfirmed(int?id)
{
if (id == null)
{
// há um xico esperto a darm-me a volta ao codigo
return(RedirectToAction("Index"));
}
// será que o ID é o que eu espero?
// vamos validar se o ID está correto
if ((int)Session["Agente"] != id)
{
// o ID é diferente do esperado
return(RedirectToAction("Index"));
}
// procura o agente a remover
Agentes agente = db.Agentes.Find(id);
if (agente == null)
{
return(RedirectToAction("Index"));
}
try
{
// dá a ordem de remoção do agente
db.Agentes.Remove(agente);
// consolida a remoção
db.SaveChanges();
}
catch (Exception)
{
// deve aqui ser escritas todas as instruções que são consideradas necessárias
//informa que houve um erro
ModelState.AddModelError("", "Não é possível remover o agente " + agente.Nome + ". Ele tem multas associadas");
//redirecionar para a pagina onde o erro foi gerado
return(View(agente));
}
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int?id)
{
if (id == null)
{
// há um 'xico esperto' a tentar dar-me a volta ao código
return(RedirectToAction("Index"));
}
// o ID não é null
// será o ID o que eu espero?
// vamos validar se o ID está correto
if (id != (int)Session["Agente"])
{
// há aqui outro 'xico esperto'...
return(RedirectToAction("Index"));
}
// procura o agente a remover
Agentes agente = db.Agentes.Find(id);
if (agente == null)
{
// não foi encontrado o Agente
return(RedirectToAction("Index"));
}
try {
// dá ordem de remoção do Agente
db.Agentes.Remove(agente);
// consolida a remoção
db.SaveChanges();
}
catch (Exception) {
// devem aqui ser escritas todas as instruções que são consideradas necessárias
//informar que houve um erro
ModelState.AddModelError("", "Não é possível remover o Agente." +
"Provavelmente, ele tem multas associadas a ele...");
// redirecionar para a página onde o erro foi gerado
return(View(agente));
}
return(RedirectToAction("Index"));
}
public ActionResult Delete(int?id)
{
//verificar se foi fornecido um ID válido
if (id == null)
{
return(RedirectToAction("Index"));
}
//pesquisar pelo Agente, cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
//verificar se o Agente foi verificado
if (agente == null)
{
//o Agente não existe
//redireciona para a página inicial
return(RedirectToAction("Index"));
}
return(View(agente));
}
// GET: Agentes/Details/5
//quando tem ? significa que pode ser preenchimento facultativo
public ActionResult Details(int?id)
{
//proteção para o caso de não ter sido fornecido um id
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//procura na BD, o agente cujo ID foi fornecido
Agentes agentes = db.Agentes.Find(id);
//proteção para o caso de não ter sido encontrado qualquer agente
//que tenha o ID fornecido
if (agentes == null)
{
return(HttpNotFound());
}
return(View(agentes));
}
public ActionResult DeleteConfirmed(int id)
{
try
{
Agentes agente = db.Agentes.Find(id);
//remove o Agente da DB
db.Agentes.Remove(agente);
//Commit
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex) {
ModelState.AddModelError("", string.Format("Não é possível apagar o Agente nº {0}-{1}, porque há multas associadas a ele", id, agente.Nome)
);
//se cheguei aqui é porque houve um problema
//devolvo os dados do agente á view
return(View(agente));
}
}
public ActionResult DeleteConfirmed(int id)
{
Agentes agentes = db.Agentes.Find(id);
try
{
//remove o agente
db.Agentes.Remove(agentes);
//commit
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("houve um erro nº {0}-{1}", id, agentes.Nome));
}
//se cheguei aqui é pqhouve um prob
return(View(agentes));
}
public ActionResult Create([Bind(Include = "Nome,Esquadra")] Agentes agente, HttpPostedFileBase fileUploadFotografia)
{
int novoID = 0;
if (db.Agentes.Count() == 0)
{
novoID = 1;
}
else
{
novoID = db.Agentes.Max(a => a.ID) + 1;
}
agente.ID = novoID;
string nomeFotografia = "Agente_" + novoID + ".jpg";
string caminhoParaFotografia = Path.Combine(Server.MapPath("~/imagens/"), nomeFotografia);
if (fileUploadFotografia != null)
{
agente.Fotografia = nomeFotografia;
}
else
{
ModelState.AddModelError("", "Nao foi fornecida uma imagem...");
return(View(agente));
}
if (ModelState.IsValid)
{
try{
db.Agentes.Add(agente);
db.SaveChanges();
fileUploadFotografia.SaveAs(caminhoParaFotografia);
return(RedirectToAction("Index"));
}
catch (Exception) {
ModelState.AddModelError("", "Ocorreu um erro nao determinado na criacao do novo agente");
}
}
return(View(agente));
}
// GET: Agentes/Details/5
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Details(int?id)
{
// se se escrever 'int?' é possível
// não fornecer o valor para o ID e não há erro
// proteção para o caso de não ter sido fornecido um ID válido
if (id == null)
{
// instrução original
// devolve um erro qd não há ID
// logo, não é possível pesquisar por um Agente
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
// procura na BD, o Agente cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
// proteção para o caso de não ter sido encontrado qq Agente
// que tenha o ID fornecido
if (agente == null)
{
// o agente não foi encontrado
// logo, gera-se uma msg de erro
// return HttpNotFound();
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
/// falta, aqui, fazer a mesma proteção
/// que foi feita no GET do método Edit
// entrega à View os dados do Agente encontrado
return(View(agente));
}
// GET: Agentes/Details/5
/// <summary>
/// Mostra os dados de um Agente
/// </summary>
/// <param name="id">identifica o Agente</param>
/// <returns>devolve a View com os dados</returns>
public ActionResult Details(int?id)
{
if (id == null)
{
// vamos alterar esta resposta por defeito
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//
// este erro ocorre porque o utilizador anda a fazer asneiras
return(RedirectToAction("Index"));
}
// SELECT * FROM Agentes WHERE Id=id
Agentes agente = db.Agentes.Find(id);
// o Agente foi encontrado?
if (agente == null)
{
// o Agente não foi encontrado, porque o utilizador está 'à pesca'
// return HttpNotFound();
return(RedirectToAction("Index"));
}
/// o Agente foi encontrado.
/// posso mostrar os seus dados a quem os solicitou?
/// sim, se
/// - o utilizador pertence ao role 'recursos humanos' ou
/// - o utilizador pertence ao role 'gestão multas' ou
/// - é o utilizador autenticado
if (User.IsInRole("RecursosHumanos") ||
User.IsInRole("GestorMultas") ||
agente.UserNameId == User.Identity.Name
)
{
// enviar para a View os dados do Agente que foi procurado e encontrado
return(View(agente));
}
else
{
// não pode ver os dados
return(RedirectToAction("Index"));
}
}
public IHttpActionResult PostAgentes(PostAgenteViewModel model)
{
if (!ModelState.IsValid)
{
// O BadRequest permite usar o ModelState
// para informar o cliente dos erros de validação
// tal como no MVC.
return(BadRequest(ModelState));
}
var agentes = new Agentes
{
ID = db.GetIdAgente(),
Nome = model.Nome,
Esquadra = model.Esquadra
};
db.Agentes.Add(agentes);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
// Seria muito provável que o método
// db.Agentes.Max(agente => agente.ID) + 1
// fizesse com que este if resultasse no Conflict (HTTP 409).
if (AgentesExists(agentes.ID))
{
return(Conflict());
}
else
{
throw;
}
}
// Num create, é boa prática devolver uma representação
// do resultado da criação do objeto na base de dados.
return(CreatedAtRoute("DefaultApi", new { id = agentes.ID }, agentes));
}
public ActionResult Edit([Bind(Include = "ID,Nome,Esquadra,Fotografia, UserName")] Agentes agentes)
{
///se o utilizador pertence á role 'GestaoDePessoa', pode efetuar a edição sem qualquer restrição
///se o utilizador não pertence á role acima referida e não é o dono, nada se pode fazer
///se o utilizador nãp pertence á role e é o dono dos dados, apenas pode alterar o 'nome' e a 'fotografia'
///tarefas:
/// 1- pesquisar os dados antigos do agente na BD
/// 2-substituir nos dados novos, o valor da 'esquadra' pelos dados antigos da 'esquadra'
/// 3-guardar dados na BD
/// nota: claro que a validação do Nome e da Fotografia também tem de acontecer
if (ModelState.IsValid)
{
//neste caso já existe um Agente
//apenas edita os dados
db.Entry(agentes).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(agentes));
}
// GET: Agentes/Details/5
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Details(int?id)
{
if (id == null)
{
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest); instrução original predefenida por defeito, pois o sistema nao sabe o detalhe do agente quer ver
//redirecionar para uma pagina que nos controlamos
return(RedirectToAction("Index"));
}
Agentes agente = db.Agentes.Find(id);
if (agente == null)
{
//o agente nao foi encontrado logo, gera-se uma msg de erro
//return HttpNotFound();
//redirecionar para uma pagina que nos controlamos
return(RedirectToAction("Index"));
}
return(View(agente));
}
// GET: Agentes/Details/5
public ActionResult Details(int?id)
// se se escrever int? é possivel não fornecer o valor de ID e não há erro!;
//proteção para o caso de não ter sido fornecido um ID vãlido;
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
// procura na BD, o Agente cujo ID foi fornecido
Agentes agentes = db.Agentes.Find(id);
//proteção para o caso de não ter sido encontrado um Agente com ID fornecido;
if (agentes == null)
{
return(HttpNotFound());
}
// entrega à View os dados do Agente encontrado;
return(View(agentes));
}
// GET: Agentes/Details/5
/// <summary>
/// Apresenta numa listagem os dados de um agente
/// </summary>
/// <param name="id">identifica o número do agente a pesquisar</param>
/// <returns></returns>
public ActionResult Details(int?id)
{
// int? id ---> o '?' informa que o parâmetro é de preenchimento facultativo
//caso não haja ID, nada é feito
if (id == null)
{
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
return(RedirectToAction("Index"));
}
// pesquisa os dados do agente, cujo ID foi fornecido
Agentes agentes = db.Agentes.Find(id);
// valida se foi encontrado algum Agente, se não foi encontrado, nada faz
if (agentes == null)
{
// return HttpNotFound();
return(RedirectToAction("Index"));
}
// apresenta na view os dados do agente
return(View(agentes));
}
// GET: Agentes/Delete/5
/// <summary>
/// apresenta na view os dados de um Agente,
/// com vista à sua, eventual, eliminacao
/// </summary>
/// <param name="id"> identificador do agente a apagar </param>
/// <returns></returns>
public ActionResult Delete(int? id)
{
//verificar se foi fornecido um ID valido
if (id == null)
{
return RedirectToAction("Index");
}
// pesquisa pelo Agente, cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
//verifica se o Agente foi encontrado
if (agente == null)
{
//o Agente nao existe
//redireciona para a pagina inicial
return RedirectToAction("Index");
}
//apresentar os dados na view
return View(agente);
}
// GET: Agentes/Delete/5
/// <summary>
/// procura os dados de um agente, e mostra-os no ecran
/// </summary>
/// <param name="id">identificador do agente a pesquisar</param>
/// <returns></returns>
public ActionResult Delete(int?id)
{
if (id == null)
{
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//ou nao foi introduzido um ID valido, ou foi introduzido um valor completamente errado
return(RedirectToAction("Index"));
}
// vai procurar o Agente cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
// se o Agente NÃO for encontrado...
if (agente == null)
{
// return HttpNotFound();
return(RedirectToAction("Index"));
}
return(View(agente));
}
public ActionResult DeleteConfirmed(int id)
{
Agentes agente = db.Agentes.Find(id);
try {
//Procurar o agente
//Remover da memória
db.Agentes.Remove(agente);
//Commit na BD
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex) {
ModelState.AddModelError("", string.Format("Não é possível apagar o Agente nº {0} - {1}, porque há multas associadas a ele...",
id, agente.Nome)
);
}
//Se cheguei aqui é pq houve um problema
//Devolvo os dados do Agente à View
return(View(agente));
}
// GET: Agentes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{ // vamos alterar esta resposta por defeito
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//
// este erro ocorre porque o utilizador anda a fazer asneiras
return(RedirectToAction("Index"));
}
// SELECT * FROM Agentes WHERE Id=id
Agentes agentes = db.Agentes.Find(id);
//o agente foi encontrado?
if (agentes == null)
{
// o Agente não foi encontrado, porque o utilizador está 'à pesca'
// return HttpNotFound();
return(RedirectToAction("Index"));
}
return(View(agentes));
}
// GET: Agentes/Delete/5
/// <summary>
/// apresenta na view os dados de um agente,
/// com vista à sua eventual
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Delete(int?id)
{
//Verificar se foi fornecido um ID válido
if (id == null)
{
return(RedirectToAction("Index"));
}
//Pesquisar pelo Agente cujo ID foi fornecido
Agentes agente = db.Agentes.Find(id);
//Verificar se o Agente foi encontrado
if (agente == null)
{
//O agente não existe
//Redirecionar para a página atual
return(RedirectToAction("Index"));
}
//Retornar para a view os dados do agente
return(View(agente));
}
