public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Apellido,FechaNacimiento,TipoDocumento,NumeroDocumento,EstadoCivil,Email,Direccion,Nacionalidad,Ciudad,CodigoPostal,Password")] Usuario usuario)
{
if (id != usuario.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(usuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioExists(usuario.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(usuario));
}
public async Task <IActionResult> Edit(int id, [Bind("RegimeId,TipoRegime")] Regime regime)
{
if (id != regime.RegimeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regime);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegimeExists(regime.RegimeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(regime));
}
public async Task <IActionResult> Edit(int id, [Bind("TurnoId,Nome,HoraInicio,HoraFim")] Turno turno)
{
if (id != turno.TurnoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(turno);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TurnoExists(turno.TurnoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(turno));
}
public async Task <IActionResult> Edit(int id, [Bind("CleanerId,CleanerName,HospitalId")] Cleaner cleaner)
{
if (id != cleaner.CleanerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cleaner);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CleanerExists(cleaner.CleanerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["HospitalId"] = new SelectList(_context.Hospitals, "HospitalId", "HospitalId", cleaner.HospitalId);
return(View(cleaner));
}
public async Task <IActionResult> Edit(int id, [Bind("PatientId,PatientName,DOB,DoctorId,NurseId,HospitalId")] Patient patient)
{
if (id != patient.PatientId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(patient);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PatientExists(patient.PatientId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DoctorId"] = new SelectList(_context.Doctors, "DoctorId", "DoctorId", patient.DoctorId);
ViewData["HospitalId"] = new SelectList(_context.Hospitals, "HospitalId", "HospitalId", patient.HospitalId);
ViewData["NurseId"] = new SelectList(_context.Nurses, "NurseId", "NurseId", patient.NurseId);
return(View(patient));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Diseases,DateIn,DateOut")] Patients patients)
{
if (id != patients.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(patients);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PatientsExists(patients.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(patients));
}
public async Task <IActionResult> Edit(Doctor editModel)
{
if (ModelState.IsValid)
{
Doctor doctor = new Doctor
{
Id = editModel.Id,
Name = editModel.Name,
Specialnost = editModel.Specialnost,
Cabinet = editModel.Cabinet,
Patients = editModel.Patients
};
try
{
hospitalDb.Update(doctor);
await hospitalDb.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DoctorExists(doctor.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(editModel));
}
public async Task <IActionResult> Edit(int id, [Bind("GrauId,TipoGrau")] Grau grau)
{
if (id != grau.GrauId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(grau);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GrauExists(grau.GrauId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(grau));
}
public async Task <IActionResult> Edit(int id, [Bind("HorarioPacienteId,DataInicio,Duracao,DataFim,PacienteId")] HorarioPaciente horarioPaciente)
{
if (id != horarioPaciente.HorarioPacienteId)
{
return(RedirectToAction(nameof(Error)));
}
if (ModelState.IsValid)
{
try
{
_context.Update(horarioPaciente);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HorarioPacienteExists(horarioPaciente.HorarioPacienteId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PacienteId"] = new SelectList(_context.Pacientes, "PacienteId", "CC", horarioPaciente.PacienteId);
return(View(horarioPaciente));
}
public async Task <IActionResult> Edit(int id, [Bind("EspecialidadeEnfermeiroId,EnfermeiroId,Data_Registo")] EnfermeiroEspecialidade enfermeiroEspecialidade)
{
if (id != enfermeiroEspecialidade.EnfermeiroId)
{
return(RedirectToAction(nameof(Error)));
}
if (ModelState.IsValid)
{
try
{
_context.Update(enfermeiroEspecialidade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnfermeiroEspecialidadeExists(enfermeiroEspecialidade.EnfermeiroId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EnfermeiroId"] = new SelectList(_context.Enfermeiros, "EnfermeiroId", "Nome", enfermeiroEspecialidade.EnfermeiroId);
ViewData["EspecialidadeEnfermeiroId"] = new SelectList(_context.Set <EspecialidadeEnfermeiro>(), "EspecialidadeEnfermeiroId", "Especialidade", enfermeiroEspecialidade.EspecialidadeEnfermeiroId);
return(View(enfermeiroEspecialidade));
}
public async Task <IActionResult> Edit(int id, [Bind("HorarioATrocarEnfermeiroId,HorarioEnfermeiroId")] HorarioATrocarEnfermeiro horarioATrocarEnfermeiro)
{
if (id != horarioATrocarEnfermeiro.HorarioATrocarEnfermeiroId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(horarioATrocarEnfermeiro);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HorarioATrocarEnfermeiroExists(horarioATrocarEnfermeiro.HorarioATrocarEnfermeiroId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["HorarioEnfermeiroId"] = new SelectList(_context.HorariosEnfermeiro, "HorarioEnfermeiroId", "HorarioEnfermeiroId", horarioATrocarEnfermeiro.HorarioEnfermeiroId);
return(View(horarioATrocarEnfermeiro));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Post,Department")] Staff staff)
{
if (id != staff.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(staff);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StaffExists(staff.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(staff));
}
public async Task <IActionResult> Edit(int id, [Bind("EstadoId,Nome")] Estado estado)
{
if (id != estado.EstadoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(estado);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstadoExists(estado.EstadoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(estado));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,PatientID,Diseases,DateIn")] Appointment appointment)
{
if (id != appointment.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(appointment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AppointmentExists(appointment.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(appointment));
}
public async Task <IActionResult> Edit(int id, [Bind("HorarioEnfermeiroId,DataInicioTurno,Duracao,DataFimTurno,TurnoId,EnfermeiroId")] HorarioEnfermeiro horarioEnfermeiro)
{
if (id != horarioEnfermeiro.HorarioEnfermeiroId)
{
return(RedirectToAction(nameof(Error)));
}
if (ModelState.IsValid)
{
try
{
_context.Update(horarioEnfermeiro);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HorarioEnfermeiroExists(horarioEnfermeiro.HorarioEnfermeiroId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EnfermeiroId"] = new SelectList(_context.Enfermeiros, "EnfermeiroId", "CC", horarioEnfermeiro.EnfermeiroId);
ViewData["TurnoId"] = new SelectList(_context.Turnos, "TurnoId", "TurnoId", horarioEnfermeiro.TurnoId);
return(View(horarioEnfermeiro));
}
public async Task <IActionResult> Edit(int id, [Bind("MedicoId,NomeEspecialidade, Data_Registo")] MedicoEspecialidade medicoEspecialidade)
{
if (id != medicoEspecialidade.MedicoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(medicoEspecialidade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MedicoEspecialidadeExists(medicoEspecialidade.MedicoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EspecialidadeMedicoId"] = new SelectList(_context.EspecialidadeMedicos, "EspecialidadeMedicoId", "NomeEspecialidade", medicoEspecialidade.EspecialidadeMedicoId);
ViewData["MedicoId"] = new SelectList(_context.Medicos, "MedicoId", "Nome", medicoEspecialidade.MedicoId);
return(View(medicoEspecialidade));
}
public async Task <IActionResult> Edit(int id, [Bind("PatologiaId,Nome")] Patologia patologia)
{
if (id != patologia.PatologiaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(patologia);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PatologiaExists(patologia.PatologiaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(patologia));
}
public async Task EditSupplierAsync(int id, string name)
{
var supplier = await this.db.Suppliers.FirstOrDefaultAsync(s => s.Id == id);
supplier.Name = name;
db.Update(supplier);
await db.SaveChangesAsync();
}
public IActionResult Lab(LabVM bd, string Payment, string offlinepay)
{
int Patient_Reg_Id = (int)HttpContext.Session.GetInt32("User_Reg_Id");
int Patient_Id = _HDB.Patients.Where(f => f.Registration_Id == Patient_Reg_Id).Select(h => h.Id).SingleOrDefault();
int sp_Id = (int)HttpContext.Session.GetInt32("Sp_Id");
int staff_id = _HDB.Staff.Where(w => w.Specialization_Id == sp_Id).Select(e => e.Id).SingleOrDefault();
Patient p;
p = _HDB.Patients.FirstOrDefault(s => s.Id == Patient_Id);
p.Medical_Record = bd.MedicalRecord;
_HDB.Update(p);
_HDB.SaveChanges();
Follow_Up fup = new Follow_Up();
fup.Patient_Id = Patient_Id;
fup.Status = "Pending";
fup.Staff_Id = staff_id;
_HDB.Add(fup);
_HDB.SaveChanges();
Follow_Up_History fuph = new Follow_Up_History();
fuph.Date = bd.Date + "T" + bd.Hour;
fuph.Follow_Up_Type_Id = bd.Id; ////Done
fuph.Follow_Up_Id = fup.Id;
_HDB.Add(fuph);
_HDB.SaveChanges();
ViewBag.message = "Your Time has been recorded";
HttpContext.Session.SetInt32("choose_test", (int)bd.Id);
// bool ofon = _HDB.Payments.Where(o => o.Patient_Id == Patient_Id).Select(i => i.Online).FirstOrDefault();
if (Payment == "PayOnline")
{
return(RedirectToAction("Payment", "Patient"));
}
else //if (offlinepay == "offlinepay")
{
return(RedirectToAction("offlinepay", "Patient"));
}
}
public async Task <IActionResult> Edit(int id)
{
var pedidoTrocaTurnosEnfermeiro = await _context.PedidoTrocaTurnosEnfermeiros.FindAsync(id);
if (id != pedidoTrocaTurnosEnfermeiro.PedidoTrocaTurnosEnfermeiroId)
{
return(RedirectToAction(nameof(Error)));
}
if (ModelState.IsValid)
{
pedidoTrocaTurnosEnfermeiro.EstadoPedidoTrocaId = 4; //Estado_ Validado
try
{
_context.Update(pedidoTrocaTurnosEnfermeiro);
await _context.SaveChangesAsync();
TempData["Validated"] = "O pedido foi validado com sucesso!";
}
catch (DbUpdateConcurrencyException)
{
if (!PedidoTrocaTurnosEnfermeiroExists(pedidoTrocaTurnosEnfermeiro.PedidoTrocaTurnosEnfermeiroId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(pedidoTrocaTurnosEnfermeiro));
}
public async Task <IActionResult> Edit(int id, [Bind("EspecialidadeEnfermeiroId,Especialidade")] EspecialidadeEnfermeiro especialidadeEnfermeiro)
{
if (id != especialidadeEnfermeiro.EspecialidadeEnfermeiroId)
{
return(RedirectToAction(nameof(Error)));
}
var nomeEspecialidade = especialidadeEnfermeiro.Especialidade;
var idEsp = especialidadeEnfermeiro.EspecialidadeEnfermeiroId;
//Validar Especialidade
if (EspecialidadeIsInvalidEdit(nomeEspecialidade, idEsp) == true)
{
//Mensagem de erro se a especialidade já existir
ModelState.AddModelError("Especialidade", "Esta especialidade já existe");
}
if (ModelState.IsValid)
{
try
{
if (!EspecialidadeIsInvalidEdit(nomeEspecialidade, idEsp))
{
_context.Update(especialidadeEnfermeiro);
await _context.SaveChangesAsync();
TempData["successEdit"] = "Especialidade alterada com sucesso";
}
}
catch (DbUpdateConcurrencyException)
{
if (!EspecialidadeEnfermeiroExists(especialidadeEnfermeiro.EspecialidadeEnfermeiroId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(especialidadeEnfermeiro));
}
public async Task AddMedicinesToPatientAsync(int patientId, int[] medicinesIds)
{
var patientMedicinesList = new List <PatientMedicine>();
var patientMedicines = await this.db.PatientMedicine.ToListAsync();
foreach (var medicineId in medicinesIds)
{
var medicine = await this.db.Medicines.FirstOrDefaultAsync(m => m.Id == medicineId);
var patient = await this.db.Patients.FirstOrDefaultAsync(p => p.Id == patientId);
if (medicine != null && medicine.Quantity > 0)
{
var patientMedicine = new PatientMedicine
{
PatientId = patientId,
MedicineId = medicineId
};
var registered = medicine.Patients.Where(pm => pm.MedicineId == medicineId && pm.PatientId == patientId).ToList();
if (registered.Count > 0)
{
continue;
}
medicine.Quantity--;
db.Update(medicine);
patientMedicinesList.Add(patientMedicine);
}
}
await this.db.AddRangeAsync(patientMedicinesList);
await this.db.SaveChangesAsync();
}
public async Task <IActionResult> Edit(int id, [Bind("TratamentoId,PatologiaId,PacienteId,GrauId,DataInicio,DataFim,DuracaoCiclo,RegimeId,EstadoId,MedicoId")] Tratamento tratamento)
{
if (id != tratamento.TratamentoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tratamento);
await _context.SaveChangesAsync();
TempData["successEdit"] = "Registo alterado com sucesso";
}
catch (DbUpdateConcurrencyException)
{
if (!TratamentoExists(tratamento.TratamentoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GrauId"] = new SelectList(_context.Grau, "GrauId", "TipoGrau", tratamento.GrauId);
ViewData["MedicoId"] = new SelectList(_context.Medicos, "MedicoId", "Nome", tratamento.MedicoId);
ViewData["PacienteId"] = new SelectList(_context.Pacientes, "PacienteId", "Nome", tratamento.PacienteId);
ViewData["PatologiaId"] = new SelectList(_context.Patologia, "PatologiaId", "Nome", tratamento.PatologiaId);
ViewData["RegimeId"] = new SelectList(_context.Regime, "RegimeId", "TipoRegime", tratamento.RegimeId);
ViewData["EstadoId"] = new SelectList(_context.Estado, "EstadoId", "Nome", tratamento.EstadoId);
return(View(tratamento));
}
public async Task <IActionResult> Edit(int id, [Bind("EnfermeiroId,NumeroMecanografico,Nome,EspecialidadeEnfermeiroId,Contacto,Email,Data_Nascimento,CC,Filhos,Data_Nascimento_Filho")] Enfermeiro enfermeiro)
{
/*************************************/
DateTime enfermeiroBDate = enfermeiro.Data_Nascimento;
var nCC = enfermeiro.CC;
var numero = enfermeiro.NumeroMecanografico;
var idEnf = enfermeiro.EnfermeiroId;
var email = enfermeiro.Email;
var idEsp = enfermeiro.EspecialidadeEnfermeiroId;
var contacto = enfermeiro.Contacto;
bool sonBDateIsInvalid = false;
if (id != enfermeiro.EnfermeiroId)
{
return(NotFound());
}
//Validar Numero Mecanografico
if (numMecIsInvalidEdit(numero, idEnf) == true)
{
//Mensagem de erro se o número mecanográfico já existir
ModelState.AddModelError("NumeroMecanografico", "Este número já existe");
}
//Validar Data de Nascimento do Enfermeiro
if (enfDateIsInvalid(enfermeiroBDate) == true)
{
//Mensagem de erro se a data de nascimento do enfermeiro for inválida
ModelState.AddModelError("Data_Nascimento", "Data de nascimento inválida");
}
//Validar Data de Nascimento do Filho + Novo
if (enfermeiro.Data_Nascimento_Filho != null)
{
DateTime sonDate = (DateTime)enfermeiro.Data_Nascimento_Filho;
if (sonDateIsInvalid(sonDate) == true)
{
sonBDateIsInvalid = true;
//Mensagem de erro se a data de nascimento do filho for inválida
ModelState.AddModelError("Data_Nascimento_Filho", "Data de nascimento inválida");
}
}
//Validar CC através do check digit
if (!ValidateNumeroDocumentoCC(nCC))
{
//Mensagem de erro se o nº de CC é inválido
ModelState.AddModelError("CC", "Nº de CC inválido");
}
//Validar Email
if (emailIsInvalidEdit(email, idEnf))
{
//Mensagem de erro se o email já existir
ModelState.AddModelError("Email", "Email já existente");
}
//Validar CC
if (ccIsInvalidEdit(nCC, idEnf))
{
//Mensagem de erro se o CC já existir
ModelState.AddModelError("CC", "Nº de CC já existente");
}
//Validar Contacto
if (contactoIsInvalidEdit(contacto, idEnf))
{
//Mensagem de erro se o CC já existir
ModelState.AddModelError("Contacto", "Contacto já existente");
}
/*******************************************/
if (ModelState.IsValid)
{
try
{
if (!contactoIsInvalidEdit(contacto, idEnf) || !ccIsInvalidEdit(nCC, idEnf) || !emailIsInvalidEdit(email, idEnf) || !numMecIsInvalidEdit(numero, idEnf) || !enfDateIsInvalid(enfermeiroBDate) || !sonBDateIsInvalid || ValidateNumeroDocumentoCC(nCC))
{
enfermeiro.NumeroMecanografico = "E" + enfermeiro.NumeroMecanografico;
_context.Update(enfermeiro);
//Verifica na tabela EnfermeiroEspecialidade se já existe o registo
if (insertNewDataIntoEnfEspecialidade(idEnf, idEsp))
{
InsertDataIntoEnfermeiroEspecialidades(_context, enfermeiro.EspecialidadeEnfermeiroId, enfermeiro.EnfermeiroId);
}
await _context.SaveChangesAsync();
TempData["successEdit"] = "Registo alterado com sucesso";
}
}
catch (DbUpdateConcurrencyException)
{
if (!EnfermeiroExists(enfermeiro.EnfermeiroId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EspecialidadeEnfermeiroId"] = new SelectList(_context.Set <EspecialidadeEnfermeiro>(), "EspecialidadeEnfermeiroId", "Especialidade", enfermeiro.EspecialidadeEnfermeiroId);
return(View(enfermeiro));
}
public async Task <IActionResult> Edit(int id, [Bind("DiretorServicoID,Codigo,Nome,Contacto,Email,CC")] DiretorServico diretorServico)
{
var numero = diretorServico.Codigo;
var email = diretorServico.Email;
var nCC = diretorServico.CC;
var idDir = diretorServico.DiretorServicoID;
var contacto = diretorServico.Contacto;
//Validar Numero Mecanografico
if (numMecIsInvalidEdit(numero, idDir) == true)
{
//Mensagem de erro se o número mecanográfico for inválido
ModelState.AddModelError("Codigo", "Este código já existe");
}
//Validar Email
if (emailIsInvalidEdit(email, idDir) == true)
{
//Mensagem de erro se o email for inválido
ModelState.AddModelError("Email", "Este email já existe");
}
//Validar CC através do check digit
if (!ValidateNumeroDocumentoCC(nCC))
{
//Mensagem de erro se o nº de CC é inválido
ModelState.AddModelError("CC", "Nº de CC inválido");
}
//Validar CC
if (ccIsInvalidEdit(nCC, idDir))
{
//Mensagem de erro se o nº de CC já existe
ModelState.AddModelError("CC", "Nº de CC já existente");
}
//Validar Contacto
if (contactoIsInvalidEdit(contacto, idDir))
{
//Mensagem de erro se o contacto já existe
ModelState.AddModelError("Contacto", "Contacto já existente");
}
if (id != diretorServico.DiretorServicoID)
{
return(RedirectToAction(nameof(Error)));
}
if (ModelState.IsValid)
{
try
{
if (!contactoIsInvalidEdit(contacto, idDir) || !ccIsInvalidEdit(nCC, idDir) || !emailIsInvalidEdit(email, idDir) || !numMecIsInvalidEdit(numero, idDir) || ValidateNumeroDocumentoCC(nCC))
{
diretorServico.Codigo = "D" + diretorServico.Codigo;
_context.Update(diretorServico);
await _context.SaveChangesAsync();
TempData["successEdit"] = "Registo alterado com sucesso";
}
}
catch (DbUpdateConcurrencyException)
{
if (!DiretorServicoExists(diretorServico.DiretorServicoID))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(diretorServico));
}
public async Task <IActionResult> Edit(int id, [Bind("PacienteId,Nome,Morada,Cod_Postal,Email,CC,Data_Nascimento,Numero_Utente,Contacto")] Paciente paciente)
{
var nCC = paciente.CC;
DateTime pacienteBDate = paciente.Data_Nascimento;
var PacienteId = paciente.PacienteId;
//Validar Data de Nascimento do Paciente
if (pacienteDateIsInvalid(pacienteBDate) == true)
{
//Mensagem de erro se a data de nascimento do paciente for inválida
ModelState.AddModelError("Data_Nascimento", "Data de nascimento inválida");
}
//Validar CC através do check digit
if (!ValidateNumeroDocumentoCC(nCC))
{
//Mensagem de erro se o nº de CC é inválido
ModelState.AddModelError("CC", "Nº de CC inválido");
}
//Validar CC
if (ccIsInvalidEdit(nCC, PacienteId))
{
//Mensagem de erro se o CC já existir
ModelState.AddModelError("CC", "Nº de CC já existente");
}
if (id != paciente.PacienteId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (!pacienteDateIsInvalid(pacienteBDate) || ValidateNumeroDocumentoCC(nCC))
{
_context.Update(paciente);
await _context.SaveChangesAsync();
TempData["successEdit"] = "Registo alterado com sucesso";
}
}
catch (DbUpdateConcurrencyException)
{
if (!PacienteExists(paciente.PacienteId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(paciente));
}
public async Task <IActionResult> Edit(int id, [Bind("MedicoId,NumeroMecanografico,Nome,Email,Contacto,CC,Data_Nascimento,EspecialidadeMedicoId,Data_Inicio_Servico")] Medico medico)
{
/***************VALIDAÇÕES**********************/
DateTime medicoBDate = medico.Data_Nascimento;
DateTime medicoISDate = medico.Data_Inicio_Servico;
var nCC = medico.CC;
var numero = medico.NumeroMecanografico;
var idMedico = medico.MedicoId;
var email = medico.Email;
var idEspecialidade = medico.EspecialidadeMedicoId;
bool medicoISDateIsInvalid = false;
if (id != medico.MedicoId)
{
return(RedirectToAction(nameof(Error)));
}
//Validar Numero Mecanografico
if (numMecIsInvalidEdit(numero, idMedico) == true)
{
//Mensagem de erro se o número mecanográfico já existir
ModelState.AddModelError("NumeroMecanografico", "Este número já existe");
}
//Validar Data de Nascimento do médico
if (medicoDateIsInvalid(medicoBDate) == true)
{
//Mensagem de erro se a data de nascimento do médico for inválida
ModelState.AddModelError("Data_Nascimento", "Data de nascimento inválida");
}
//Validar CC através do check digit
if (!ValidateNumeroDocumentoCC(nCC))
{
//Mensagem de erro se o nº de CC é inválido
ModelState.AddModelError("CC", "Nº de Cartão de Cidadão inválido");
}
//Validar Email
if (emailIsInvalidEdit(email, idMedico))
{
//Mensagem de erro se o email já existir
ModelState.AddModelError("Email", "Email já existente");
}
//Validar CC
if (ccIsInvalidEdit(nCC, idMedico))
{
//Mensagem de erro se o CC já existir
ModelState.AddModelError("CC", "Nº de Cartão de Cidadão já existente");
}
//Validar Data de inicio de serviço do médico
if (medicoInSerDateIsInvalid(medicoISDate, medicoBDate) == true)
{
medicoISDateIsInvalid = true;
//Mensagem de erro se a data de inicio de serviço do médico for inválida
ModelState.AddModelError("Data_Inicio_Servico", "Data de inicio de serviço inválida");
}
/*******************************************/
if (ModelState.IsValid)
{
try
{
if (!ccIsInvalidEdit(nCC, idMedico) || !emailIsInvalidEdit(email, idMedico) || !numMecIsInvalidEdit(numero, idMedico) || !medicoDateIsInvalid(medicoBDate) || ValidateNumeroDocumentoCC(nCC) || !medicoISDateIsInvalid)
{
_context.Update(medico);
//Verifica na tabela MedicoEspecialidade se já existe o registo
if (insertNewDataIntoMedicoEspecialidade(idMedico, idEspecialidade))
{
InsertDataIntoMedicoEspecialidades(_context, medico.EspecialidadeMedicoId, medico.MedicoId);
}
await _context.SaveChangesAsync();
TempData["successEdit"] = "Registo alterado com sucesso";
}
}
catch (DbUpdateConcurrencyException)
{
if (!MedicoExists(medico.MedicoId))
{
return(RedirectToAction(nameof(Error)));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EspecialidadeMedicoId"] = new SelectList(_context.Set <EspecialidadeMedico>(), "EspecialidadeMedicoId", "NomeEspecialidade", medico.EspecialidadeMedicoId);
return(View(medico));
}