public async Task <IActionResult> Edit(int id, [Bind("Id,NomeConselho,DistritoId")] Conselho conselho)
{
if (id != conselho.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(conselho);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConselhoExists(conselho.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DistritoId"] = new SelectList(_context.Distrito, "Id", "Id", conselho.DistritoId);
return(View(conselho));
}
public async Task <IActionResult> Edit(int id, [Bind("IdLocalCaptura,Localidade,Latitude,Longitude,ConselhoId,ConselhoDistritoId")] Localcaptura localcaptura)
{
if (id != localcaptura.IdLocalCaptura)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(localcaptura);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocalcapturaExists(localcaptura.IdLocalCaptura))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ConselhoId"] = new SelectList(_context.Conselho, "Id", "NomeConselho", localcaptura.ConselhoId);
return(View(localcaptura));
}
public async Task <IActionResult> Edit(int id, [Bind("IdTipoEstatutoGenetico,TipoEstatutoGeneticocol")] Tipoestatutogenetico tipoestatutogenetico)
{
if (id != tipoestatutogenetico.IdTipoEstatutoGenetico)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tipoestatutogenetico);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoestatutogeneticoExists(tipoestatutogenetico.IdTipoEstatutoGenetico))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoestatutogenetico));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,NomeDistrito")] Distrito distrito)
{
if (id != distrito.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(distrito);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DistritoExists(distrito.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(distrito));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegMan,Data,TipoManuntecaoIdTManutencao,TanqueIdTanque")] RegManutencao regManutencao)
{
if (id != regManutencao.IdRegMan || regManutencao.isarchived == 1)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regManutencao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegManutencaoExists(regManutencao.IdRegMan))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque", regManutencao.TanqueIdTanque);
ViewData["TipoManuntecaoIdTManutencao"] = new SelectList(_context.TipoManuntecao, "IdTManutencao", "TManutencao", regManutencao.TipoManuntecaoIdTManutencao);
return(View(regManutencao));
}
public async Task <IActionResult> Edit(int id, [Bind("IdPlanAlim,Nome,MarcaAlim,Tipo,Temperatura,Racao,RacaoDia")] PlanoAlimentar planoAlimentar)
{
if (id != planoAlimentar.IdPlanAlim)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(planoAlimentar);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlanoAlimentarExists(planoAlimentar.IdPlanAlim))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(planoAlimentar));
}
public async Task <IActionResult> Edit(int id, [Bind("IdMotivo,TipoMotivo,NomeMotivo")] Motivo motivo)
{
if (id != motivo.IdMotivo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(motivo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MotivoExists(motivo.IdMotivo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(motivo));
}
public async Task <IActionResult> Edit(int id, [Bind("IdProjeto,Nome,DataInicio,DataFim,AutorizacaoDgva,RefOrbea,SubmisInsEurop,NroAnimaisAutoriz")] Projeto projeto)
{
if (id != projeto.IdProjeto || projeto.isarchived == 1)
{
return(NotFound());
}
if (projeto.DataFim < projeto.DataInicio)
{
ModelState.AddModelError("DataFim", "A Data de Fim é menor que a Data de Inicio");
ModelState.AddModelError("DataInicio", "A Data de Fim é menor que a Data de Inicio");
}
if (ModelState.IsValid)
{
try
{
_context.Update(projeto);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjetoExists(projeto.IdProjeto))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(projeto));
}
public async Task <IActionResult> Edit(int id, [Bind("IdTOrigem,descricao")] TOrigem tOrigem)
{
if (id != tOrigem.IdTOrigem)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tOrigem);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TOrigemExists(tOrigem.IdTOrigem))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tOrigem));
}
public async Task <IActionResult> Edit(int id, [Bind("IdTManutencao,TManutencao")] TipoManuntecao tipoManuntecao)
{
if (id != tipoManuntecao.IdTManutencao)
{
return(NotFound());
}
var cTCodefindany = _context.TipoManuntecao.Where(b => EF.Property <string>(b, "TManutencao").Equals(tipoManuntecao.TManutencao));
if (cTCodefindany.Any())
{
ModelState.AddModelError("TManutencao", string.Format("Este Tipo de Manutenção já existe.", tipoManuntecao.TManutencao));
}
if (ModelState.IsValid)
{
try
{
_context.Update(tipoManuntecao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoManuntecaoExists(tipoManuntecao.IdTManutencao))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoManuntecao));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegAmo,Data,PesoMedio,NroIndividuos,PesoTotal,TanqueIdTanque")] RegAmostragens regAmostragens)
{
if (id != regAmostragens.IdRegAmo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regAmostragens);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegAmostragensExists(regAmostragens.IdRegAmo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque, "IdTanque", "codidenttanque", regAmostragens.TanqueIdTanque);
return(View(regAmostragens));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegRemo,Date,NroRemoções,MotivoIdMotivo,CausaMorte,TanqueIdTanque")] RegRemocoes regRemocoes)
{
if (id != regRemocoes.IdRegRemo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regRemocoes);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegRemocoesExists(regRemocoes.IdRegRemo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MotivoIdMotivo"] = new SelectList(_context.Motivo, "IdMotivo", "NomeMotivo", regRemocoes.MotivoIdMotivo);
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque, "IdTanque", "Sala", regRemocoes.TanqueIdTanque);
return(View(regRemocoes));
}
public async Task<IActionResult> Edit(int id, [Bind("IdRegAnimal,NroExemplares,NroMachos,NroFemeas,Imaturos,Juvenis,Larvas,Ovos,DataNasc,Idade,PesoMedio,CompMedio,DuracaoViagem,TempPartida,TempChegada,NroContentores,TipoContentor,VolContentor,VolAgua,NroCaixasIsoter,NroMortosCheg,SatO2transp,Anestesico,Gelo,AdicaoO2,Arejamento,Refrigeracao,Sedação,RespTransporte,EspecieIdEspecie,FornecedorIdFornColect,TOrigemIdTOrigem,LocalCapturaIdLocalCaptura,TipoEstatutoGeneticoIdTipoEstatutoGenetico,FuncionarioIdFuncionario,FuncionarioIdFuncionario1")] RegNovosAnimais regNovosAnimais)
{
if (id != regNovosAnimais.IdRegAnimal)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(regNovosAnimais);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegNovosAnimaisExists(regNovosAnimais.IdRegAnimal))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
ViewData["FornecedorIdFornColect"] = new SelectList(_context.Fornecedorcolector, "IdFornColect", "Tipo", regNovosAnimais.FornecedorIdFornColect);
ViewData["FuncionarioIdFuncionario1"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", regNovosAnimais.FuncionarioIdFuncionario1);
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", regNovosAnimais.FuncionarioIdFuncionario);
ViewData["TOrigemIdTOrigem"] = new SelectList(_context.TOrigem, "IdTOrigem", "IdTOrigem", regNovosAnimais.TOrigemIdTOrigem);
ViewData["TipoEstatutoGeneticoIdTipoEstatutoGenetico"] = new SelectList(_context.Tipoestatutogenetico, "IdTipoEstatutoGenetico", "IdTipoEstatutoGenetico", regNovosAnimais.TipoEstatutoGeneticoIdTipoEstatutoGenetico);
return View(regNovosAnimais);
}
public async Task <IActionResult> Edit(int id, [Bind("IdAgenTra,NomeAgenTra")] AgenteTrat agenteTrat)
{
if (id != agenteTrat.IdAgenTra)
{
return(NotFound());
}
var cTCodefindany = _context.AgenteTrat.Where(b => EF.Property <string>(b, "NomeAgenTra").Equals(agenteTrat.NomeAgenTra));
if (cTCodefindany.Any())
{
ModelState.AddModelError("NomeAgenTra", string.Format("Este Agente de Tratamento já existe.", agenteTrat.NomeAgenTra));
}
if (ModelState.IsValid)
{
try
{
_context.Update(agenteTrat);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AgenteTratExists(agenteTrat.IdAgenTra))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(agenteTrat));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFornColect,Tipo,Nome,Nif,NroLicenca,Morada,Telefone")] Fornecedorcolector fornecedorcolector)
{
if (id != fornecedorcolector.IdFornColect)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(fornecedorcolector);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FornecedorcolectorExists(fornecedorcolector.IdFornColect))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(fornecedorcolector));
}
public async Task <IActionResult> Edit(int id, [Bind("Função,ProjetoIdProjeto,FuncionarioIdFuncionario")] Elementoequipa elementoequipa)
{
if (id != elementoequipa.ProjetoIdProjeto)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(elementoequipa);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElementoequipaExists(elementoequipa.ProjetoIdProjeto))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", elementoequipa.FuncionarioIdFuncionario);
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto, "IdProjeto", "Nome", elementoequipa.ProjetoIdProjeto);
return(View(elementoequipa));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFinalidade,TFinalidade")] Finalidade finalidade)
{
if (id != finalidade.IdFinalidade)
{
return(NotFound());
}
var cTCodefindany = _context.Finalidade.Where(b => EF.Property <string>(b, "TFinalidade").Equals(finalidade.TFinalidade));
if (cTCodefindany.Any())
{
ModelState.AddModelError("TFinalidade", string.Format("Esta Finalidade já existe.", finalidade.TFinalidade));
}
if (ModelState.IsValid)
{
try
{
_context.Update(finalidade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FinalidadeExists(finalidade.IdFinalidade))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(finalidade));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFuncionario,NomeCompleto,NomeUtilizador,Password,Telefone")] Funcionario funcionario)
{
if (id != funcionario.IdFuncionario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionarioExists(funcionario.IdFuncionario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(funcionario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegAnimal,NroExemplares,NroMachos,NroFemeas,Imaturos,Juvenis,Larvas,Ovos,DataNasc,Idade,PesoMedio,CompMedio,DuracaoViagem,TempPartida,TempChegada,NroContentores,TipoContentor,VolContentor,VolAgua,NroCaixasIsoter,NroMortosCheg,SatO2transp,Anestesico,Gelo,AdicaoO2,Arejamento,Refrigeracao,sedacao,RespTransporte,EspecieIdEspecie,FornecedorIdFornColect,TOrigemIdTOrigem,LocalCapturaIdLocalCaptura,TipoEstatutoGeneticoIdTipoEstatutoGenetico,FuncionarioIdFuncionario,FuncionarioIdFuncionario1")] RegNovosAnimais regNovosAnimais)
{
if (id != regNovosAnimais.IdRegAnimal)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regNovosAnimais);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegNovosAnimaisExists(regNovosAnimais.IdRegAnimal))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EspecieIdEspecie"] = new SelectList(_context.Especie, "IdEspecie", "NomeCient").Prepend(new SelectListItem()
{
Text = "---Selecione uma Espécie---", Value = ""
});
ViewData["FornecedorIdFornColect"] = new SelectList(_context.Fornecedorcolector, "IdFornColect", "Nome").Prepend(new SelectListItem()
{
Text = "---Selecione um Fornecedor/Colector---", Value = ""
});
ViewData["FuncionarioIdFuncionario1"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto").Prepend(new SelectListItem()
{
Text = "---Selecione um Funcionário---", Value = ""
});
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto").Prepend(new SelectListItem()
{
Text = "---Selecione um Funcionário---", Value = ""
});
var locais =
_context.Localcaptura
.Select(s => new
{
LocalId = s.IdLocalCaptura,
Description = string.Format("{0} ({1} {2})", s.Localidade, s.Latitude, s.Longitude)
})
.ToList();
ViewData["LocalCapturaIdLocalCaptura"] = new SelectList(locais, "LocalId", "Description").Prepend(new SelectListItem()
{
Text = "---Selecione um Local de Captura---", Value = ""
});
ViewData["TOrigem"] = new List <TOrigem>(_context.TOrigem);
ViewData["TipoEstatutoGenetico"] = new List <Tipoestatutogenetico>(_context.Tipoestatutogenetico);
return(View(regNovosAnimais));
}
public async Task <IActionResult> Edit(int id, [Bind("IdLocalCaptura,Localidade,Latitude,Longitude,ConcelhoId,DistritoId")] Localcaptura localcaptura)
{
if (id != localcaptura.IdLocalCaptura)
{
return(NotFound());
}
//validation
var val_concelho_distrito = await _context.Concelho
.SingleOrDefaultAsync(m => m.IdConcelho == localcaptura.ConcelhoId);
if (val_concelho_distrito.DistritoId != localcaptura.DistritoId)
{
ModelState.AddModelError("DistritoId", "O distrito selecionado não contém o concelho selecionado.");
ModelState.AddModelError("ConcelhoId", "O concelho selecionado não pertence ao distrito selecionado.");
}
if (ModelState.IsValid)
{
try
{
_context.Update(localcaptura);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocalcapturaExists(localcaptura.IdLocalCaptura))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DistritoId"] = new SelectList(_context.Distrito, "IdDistrito", "NomeDistrito").Prepend(new SelectListItem()
{
Text = "---Selecione um Distrito---", Value = ""
});
ViewData["ConcelhoId"] = new SelectList(_context.Concelho, "IdConcelho", "NomeConcelho").Prepend(new SelectListItem()
{
Text = "---Selecione um Concelho---", Value = ""
});
return(View(localcaptura));
}
public async Task <IActionResult> Edit(int id, [Bind("IdCircuito,ProjetoIdProjeto,CodigoCircuito,DataCriacao,DataFinal")] CircuitoTanque circuitoTanque)
{
if (id != circuitoTanque.IdCircuito || circuitoTanque.isarchived == 1)
{
return(NotFound());
}
if (circuitoTanque.DataCriacao > circuitoTanque.DataFinal)
{
ModelState.AddModelError("DataCriacao", string.Format("Data inicial não pode ser posterior á data inicial", circuitoTanque.DataCriacao));
}
var cTfindany = _context.CircuitoTanque.Where(b => EF.Property <int>(b, "ProjetoIdProjeto") == circuitoTanque.ProjetoIdProjeto).Where(b => EF.Property <int>(b, "isarchived") == 0).Where(b => EF.Property <int>(b, "IdCircuito") != circuitoTanque.IdCircuito);
if (cTfindany.Any())
{
ModelState.AddModelError("ProjetoIdProjeto", string.Format("Este Projecto ja possui um Circuito Tanque Associado", circuitoTanque.ProjetoIdProjeto));
}
var cTCodefindany = _context.CircuitoTanque.Where(b => EF.Property <string>(b, "CodigoCircuito").Equals(circuitoTanque.CodigoCircuito)).Where(b => EF.Property <int>(b, "IdCircuito") != circuitoTanque.IdCircuito);
if (cTCodefindany.Any())
{
ModelState.AddModelError("CodigoCircuito", string.Format("Já Existe um circuito com este Código", circuitoTanque.CodigoCircuito));
}
if (ModelState.IsValid)
{
try
{
_context.Update(circuitoTanque);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CircuitoTanqueExists(circuitoTanque.IdCircuito))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto.Where(p => p.isarchived == 0), "IdProjeto", "Nome", circuitoTanque.ProjetoIdProjeto);
return(View(circuitoTanque));
}
public async Task <IActionResult> Edit(int id, [Bind("IdEnsaio,DataInicio,DataFim,DescTratamento,GrauSeveridade,NroAnimaisAutoriz,ProjetoIdProjeto,LoteIdLote")] Ensaio ensaio)
{
if (id != ensaio.IdEnsaio)
{
return(NotFound());
}
if (ensaio.DataFim < ensaio.DataInicio)
{
ModelState.AddModelError("DataFim", "A Data de Fim é menor que a Data de Inicio");
ModelState.AddModelError("DataInicio", "A Data de Fim é menor que a Data de Inicio");
}
var projetos = _context.Projeto.Where(b => EF.Property <int>(b, "IdProjeto") == ensaio.ProjetoIdProjeto);
foreach (var projeto in projetos)
{
if (ensaio.NroAnimaisAutoriz > projeto.NroAnimaisAutoriz)
{
ModelState.AddModelError("NroAnimaisAutoriz", "Nº de Animais excede o permitido para o Projeto selecionado" + "(" + projeto.NroAnimaisAutoriz + ")");
}
}
if (ModelState.IsValid)
{
try
{
_context.Update(ensaio);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnsaioExists(ensaio.IdEnsaio))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["LoteIdLote"] = new SelectList(_context.Lote, "IdLote", "CodigoLote", ensaio.LoteIdLote);
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto, "IdProjeto", "Nome", ensaio.ProjetoIdProjeto);
return(View(ensaio));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,NomeConcelho,DistritoId")] Concelho concelho)
{
if (id != concelho.IdConcelho)
{
return(NotFound());
}
//validation
var val_nome = await _context.Concelho
.SingleOrDefaultAsync(m => m.NomeConcelho == concelho.NomeConcelho);
if (val_nome != null && val_nome.NomeConcelho != concelho.NomeConcelho)
{
ModelState.AddModelError("NomeDistrito", string.Format("Já existe um concelho com o nome {0}.", concelho.NomeConcelho));
}
if (ModelState.IsValid)
{
try
{
_context.Update(concelho);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConcelhoExists(concelho.IdConcelho))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DistritoId"] = new SelectList(_context.Distrito, "IdDistrito", "NomeDistrito", concelho.DistritoId).Prepend(new SelectListItem()
{
Text = "---Selecione um Distrito---", Value = ""
});;
return(View(concelho));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegCondAmb,Data,Temperatura,VolAgua,SalinidadeAgua,NivelO2,CircuitoTanqueIdCircuito")] RegCondAmb regCondAmb)
{
if (id != regCondAmb.IdRegCondAmb)
{
return(NotFound());
}
if (regCondAmb.VolAgua < 0)
{
ModelState.AddModelError("VolAgua", string.Format("Este valor tem de ser positivo", regCondAmb.VolAgua));
}
if (regCondAmb.SalinidadeAgua < 0)
{
ModelState.AddModelError("SalinidadeAgua", string.Format("Este valor tem de ser positivo", regCondAmb.SalinidadeAgua));
}
if (regCondAmb.NivelO2 < 0)
{
ModelState.AddModelError("NivelO2", string.Format("Este valor tem de ser positivo", regCondAmb.NivelO2));
}
if (ModelState.IsValid)
{
try
{
_context.Update(regCondAmb);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegCondAmbExists(regCondAmb.IdRegCondAmb))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CircuitoTanqueIdCircuito"] = new SelectList(_context.CircuitoTanque.Where(p => p.isarchived == 0), "IdCircuito", "CodigoCircuito", regCondAmb.CircuitoTanqueIdCircuito);
return(View(regCondAmb));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegTra,Date,Tempo,Concentracao,FinalidadeIdFinalidade,AgenteTratIdAgenTra,ConcAgenTra,TanqueIdTanque")] RegTratamento regTratamento)
{
if (id != regTratamento.IdRegTra || regTratamento.isarchived == 1)
{
return(NotFound());
}
if (regTratamento.Tempo < 0)
{
ModelState.AddModelError("Tempo", string.Format("Este valor tem que ser positivo", regTratamento.Tempo));
}
if (regTratamento.Concentracao < 0)
{
ModelState.AddModelError("Concentracao", string.Format("Este valor tem que ser positivo", regTratamento.Concentracao));
}
if (ModelState.IsValid)
{
try
{
_context.Update(regTratamento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegTratamentoExists(regTratamento.IdRegTra))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AgenteTratIdAgenTra"] = new SelectList(_context.AgenteTrat, "IdAgenTra", "NomeAgenTra", regTratamento.AgenteTratIdAgenTra);
ViewData["FinalidadeIdFinalidade"] = new SelectList(_context.Finalidade, "IdFinalidade", "IdFinalidade", regTratamento.FinalidadeIdFinalidade);
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque", regTratamento.TanqueIdTanque);
return(View(regTratamento));
}
public async Task <IActionResult> Edit(int id, [Bind("IdLote,CodigoLote,DataInicio,DataFim,Observacoes,RegNovosAnimaisIdRegAnimal,FuncionarioIdFuncionario")] Lote lote)
{
if (id != lote.IdLote)
{
return(NotFound());
}
//validation
var val_code = await _context.Lote
.SingleOrDefaultAsync(m => m.CodigoLote == lote.CodigoLote);
if (val_code != null && val_code.IdLote != lote.IdLote)
{
ModelState.AddModelError("CodigoLote", string.Format("Já existe um lote com o código {0}.", lote.CodigoLote));
}
if (ModelState.IsValid)
{
try
{
_context.Update(lote);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LoteExists(lote.IdLote))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", lote.FuncionarioIdFuncionario);
ViewData["RegNovosAnimaisIdRegAnimal"] = new SelectList(_context.RegNovosAnimais, "IdRegAnimal", "RespTransporte", lote.RegNovosAnimaisIdRegAnimal);
return(View(lote));
}
public async Task <IActionResult> Edit(int id, [Bind("IdRegAlim,Data,Peso,Sobras,PlanoAlimentarIdPlanAlim,TanqueIdTanque")] RegAlimentar regAlimentar)
{
if (id != regAlimentar.IdRegAlim)
{
return(NotFound());
}
if (regAlimentar.Peso < 0)
{
ModelState.AddModelError("Peso", string.Format("Este valor tem de ser positivo", regAlimentar.Peso));
}
if (regAlimentar.Sobras < 0)
{
ModelState.AddModelError("Sobras", string.Format("Este valor tem de ser positivo", regAlimentar.Sobras));
}
if (ModelState.IsValid)
{
try
{
_context.Update(regAlimentar);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegAlimentarExists(regAlimentar.IdRegAlim))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PlanoAlimentarIdPlanAlim"] = new SelectList(_context.PlanoAlimentar, "IdPlanAlim", "Nome", regAlimentar.PlanoAlimentarIdPlanAlim);
ViewData["TanqueIdTanque"] = new SelectList(_context.Tanque.Where(p => p.isarchived == 0), "IdTanque", "codidenttanque", regAlimentar.TanqueIdTanque);
return(View(regAlimentar));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,NomeDistrito")] Distrito distrito)
{
if (id != distrito.IdDistrito)
{
return(NotFound());
}
//validation
var val_nome = await _context.Distrito
.SingleOrDefaultAsync(m => m.NomeDistrito == distrito.NomeDistrito);
if (val_nome != null && val_nome.IdDistrito != distrito.IdDistrito)
{
ModelState.AddModelError("NomeDistrito", string.Format("Já existe um distrito com o nome {0}.", distrito.NomeDistrito));
}
if (ModelState.IsValid)
{
try
{
_context.Update(distrito);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DistritoExists(distrito.IdDistrito))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(distrito));
}
public async Task <IActionResult> Edit(int id, [Bind("IdElementoEquipa,Nome,Função,ProjetoIdProjeto,FuncionarioIdFuncionario")] Elementoequipa elementoequipa)
{
if (id != elementoequipa.IdElementoEquipa)
{
return(NotFound());
}
var cTCodefindany = _context.Elementoequipa.Where(b => EF.Property <string>(b, "Nome").Equals(elementoequipa.Nome)).Where(b => EF.Property <int>(b, "ProjetoIdProjeto") == elementoequipa.ProjetoIdProjeto).Where(b => EF.Property <int>(b, "IdElementoEquipa") != b.IdElementoEquipa);
if (cTCodefindany.Any())
{
ModelState.AddModelError("Nome", string.Format("Este Elemento de Equipa já se encontra associado a este Projeto!", elementoequipa.ProjetoIdProjeto));
}
elementoequipa.FuncionarioIdFuncionario = 1;
if (ModelState.IsValid)
{
try
{
_context.Update(elementoequipa);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElementoequipaExists(elementoequipa.IdElementoEquipa))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FuncionarioIdFuncionario"] = new SelectList(_context.Funcionario, "IdFuncionario", "NomeCompleto", elementoequipa.FuncionarioIdFuncionario);
ViewData["ProjetoIdProjeto"] = new SelectList(_context.Projeto.Where(p => p.isarchived == 0), "IdProjeto", "Nome", elementoequipa.ProjetoIdProjeto);
return(View(elementoequipa));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFornColect,Tipo,Nome,Nif,NroLicenca,Morada,Telefone")] Fornecedorcolector fornecedorcolector)
{
if (id != fornecedorcolector.IdFornColect)
{
return(NotFound());
}
//validation
if (!validateNIF(fornecedorcolector.Nif))
{
ModelState.AddModelError("Nif", "Insira um NIF válido.");
}
if (ModelState.IsValid)
{
try
{
_context.Update(fornecedorcolector);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FornecedorcolectorExists(fornecedorcolector.IdFornColect))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Tipo"] = types;
return(View(fornecedorcolector));
}