public virtual JsonResult Crear(Laboratorio entidad)
{
var jsonResponse = new JsonResponse {Success = false};
if (ModelState.IsValid)
{
try
{
entidad.UsuarioCreacion = UsuarioActual.IdUsuario.ToString();
entidad.UsuarioModificacion = UsuarioActual.IdUsuario.ToString();
// data temporal
if (entidad.IDTipoLaboratorio == null || entidad.IDTipoLaboratorio == 0)
entidad.IDTipoLaboratorio = 1;
// fin data
LaboratorioBL.Instancia.Add(entidad);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con éxito";
}
catch (Exception ex)
{
logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
}
}
else
{
jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
}
return Json(jsonResponse, JsonRequestBehavior.AllowGet);
}
public void alteraLaboratorio(Laboratorio laboratorio)
{
alteraPessoaJuridica(laboratorio);
using (OdbcConnection conexao = ConexaoPadrao.createConnection())
{
}
}
public Monitor(Laboratorio lab, TimeSpan intervalo)
{
this.lab = lab;
timer = new DispatcherTimer();
timer.Interval = intervalo;
timer.Tick += timerTick;
mw = new MonitorWindow();
mw.Title = lab.Descricao;
}
static void Main(string[] args)
{
Laboratorio l = new Laboratorio();
Medicamento m1 = new Medicamento("Omeprazol", ETipo.VentaLibre);
Medicamento m2 = new Medicamento("Paracetamol", ETipo.VentaLibre);
Medicamento m3 = new Medicamento("Ibuprofeno", ETipo.VentaLibre);
Medicamento m4 = new Medicamento("Corticoides", ETipo.Recetado);
Medicamento m5 = new Medicamento("Buscapina", ETipo.Recetado);
Medicamento m6 = new Medicamento("Sputnik V", ETipo.Recetado);
try
{
l.medicamentos.Add(m1);
l.medicamentos.Add(m2);
l.medicamentos.Add(m3);
l.medicamentos.Add(m4);
l.medicamentos.Add(m5);
l.medicamentos.Add(m6);
}
catch (MedicamentoRepetidoException ex)
{
Console.WriteLine(ex.Message);
}
foreach (Medicamento m in l.medicamentos)
{
Console.WriteLine(m.ToString());
Console.WriteLine("");
}
try
{
if (Laboratorio.Escribir(l, "DatosDeConsola.xml"))
{
Console.WriteLine($"\nSe guardaron los datos en formato xml.");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
public bool Existe(Laboratorio laboratorio)
{
if (laboratorio.LaboratorioId == 0)
{
return(_context.Laboratorios.Any(l => l.Descripcion == laboratorio.Descripcion));
}
return(_context.Laboratorios.Any(l => l.Descripcion == laboratorio.Descripcion &&
l.LaboratorioId == laboratorio.LaboratorioId));
}
protected void ckbDescarteDireto_CheckedChanged(object sender, EventArgs e)
{
try
{
foreach (RepeaterItem item in rptCadastros.Items)
{
Label lblIdCadastro = (Label)item.FindControl("lblIdCadastro");
CheckBox ckbDescarteDireto = (CheckBox)item.FindControl("ckbDescarteDireto");
if (!string.IsNullOrEmpty(lblIdCadastro.Text))
{
if (ckbDescarteDireto.Checked)
{
List <Laboratorio> labsDD = ListarLabsDescarteDireto();
labsDD = labsDD.Where(x => x.PkIdLaboratorio.ToString() == lblIdCadastro.Text.Trim()).ToList();
if (labsDD.Count <= 0)
{
Laboratorio lab = new Laboratorio()
{
PkIdLaboratorio = Convert.ToInt32(lblIdCadastro.Text.Trim()),
};
AdicionaLabDescarteDireto(lab);
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox", "alert('Laboratório inserido no Descarte Direto com sucesso!');", true);
}
}
else
{
List <Laboratorio> labsDD = ListarLabsDescarteDireto();
labsDD = labsDD.Where(x => x.PkIdLaboratorio.ToString() == lblIdCadastro.Text.Trim()).ToList();
if (labsDD.Count > 0)
{
for (int idLab = 0; idLab < labsDD.Count; idLab++)
{
if (!string.IsNullOrEmpty(labsDD[idLab].PkIdLaboratorio.ToString()) && labsDD[idLab].PkIdLaboratorio != 0)
{
ExcluirLabDescarteDireto(labsDD[idLab].PkIdLaboratorio);
}
}
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox", "alert('Laboratório removid do Descarte Direto com sucesso!');", true);
}
}
DesmarcaSelecionados();
}
}
}
catch (Exception ex)
{
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox",
"alert('Ocorreu um erro e não foi possível </ br> incluir o Laboratório no Descarte Direto!');", true);
}
}
public static int insertarLaboratorio(Laboratorio l)
{
int respuesta = 0;
SqlConnection sqlConnection = new SqlConnection();
try
{
sqlConnection = Conexion.getInstancia().CrearConexion();
SqlCommand command = new SqlCommand("sp_insertarLaboratorio", sqlConnection);
command.CommandType = CommandType.StoredProcedure;
//Agregamos los parametros:
command.Parameters.Add("@var_nombre", SqlDbType.VarChar).Value = l.Nombre;
//Agregamos los parametros de salida (idLaboratorio)
SqlParameter idLab = new SqlParameter();
idLab.ParameterName = "@var_idLaboratorio";
idLab.SqlDbType = SqlDbType.Int;
idLab.Direction = ParameterDirection.Output;
//Agregamos los parametros de salida (claveLaboratorio)
SqlParameter claveLab = new SqlParameter();
claveLab.ParameterName = "@var_claveLaboratorio";
claveLab.SqlDbType = SqlDbType.VarChar;
claveLab.Size = 30;
claveLab.Direction = ParameterDirection.Output;
//Abrimos la conexion y guardamos el resultado en respuesta
command.Parameters.Add(idLab);
command.Parameters.Add(claveLab);
sqlConnection.Open();
if (command.ExecuteNonQuery() >= 1) // el 1 respresenta un resultado exitoso (1 row affected)
{
//Esto quiere decir que se ingresó el provedor correctamente
respuesta = 1;
}
else
{
respuesta = 0;
}
}
catch (Exception e)
{
respuesta = 0;
}
finally
{
if (sqlConnection.State == ConnectionState.Open)
{
sqlConnection.Close();
}
}
return(respuesta);
}
public void AdicionaLabDescarteDireto(Laboratorio lab)
{
XElement x = new XElement("PkIdLaboratorio");
x.Add(lab.PkIdLaboratorio);
XElement xml = XElement.Load(CaminhoPastaXML());
xml.Add(x);
xml.Save(CaminhoPastaXML());
}
private void ClearFields()
{
l = null;
txtNombre.Text = "";
txtDireccion.Text = "";
txtEmail.Text = "";
cbEstado.Text = "";
txtTelefono.Text = "";
}
public void inserirLaboratorio(Laboratorio laboratorio)
{
inserirPessoaJuridica(laboratorio);
laboratorio.id = Convert.ToInt32(consultaPessoaJuridica("select top 1 ID_PESSOA_JURIDICA from PESSOA_JURIDICA order by ID_PESSOA_JURIDICA desc").Rows[0][0].ToString());
using (OdbcConnection conexao = ConexaoPadrao.createConnection())
{
}
}
public ActionResult Edit([Bind(Include = "Id,Nombre,Email,Direccion")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Entry(laboratorio).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(laboratorio));
}
/// <summary>
/// Descripción: Metodo para validar que el dato no esté vacio o sea nulo.
/// Author: Terceros.
/// Fecha Creacion: 01/01/2017
/// Fecha Modificación: 1.02/02/2017.
/// 2.06/04/2017
/// Modificación: 1.Se agregaron comentarios.
/// 2.Se modifica el retorno agregando el CodigoUnico - Juan Muga.
/// </summary>
/// <param name="laboratorio"></param>
/// <param name="nombreBusqueda"></param>
/// <returns></returns>
private static bool IsValidLaboratorio(Laboratorio laboratorio, string nombreBusqueda)
{
int intParsed;
if (int.TryParse(nombreBusqueda.Trim(), out intParsed))
{
nombreBusqueda = Convert.ToString(intParsed);
}
return(!string.IsNullOrEmpty(laboratorio.Nombre) && laboratorio.Nombre.ToUpper().Contains(nombreBusqueda) || laboratorio.CodigoUnico.Contains(nombreBusqueda));
}
public ActionResult Edit([Bind(Include = "LaboratorioID,NumClase,Capacidad")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Entry(laboratorio).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(laboratorio));
}
// GET: api/Laboratorios/5
public HttpResponseMessage Get(int id)
{
var laboratorioBo = new LaboratorioBo();
Laboratorio obj = laboratorioBo.ObterPorId(id);
var response = Request.CreateResponse(HttpStatusCode.OK, obj);
return(response);
}
private void SincronizaFabricantes()
{
try
{
migrationTable = migrationTableController.SelectOne(3);
migrationFields = migrationFieldController.SelectByTableId(migrationTable.MigrationTableId);
Sql = "SELECT ";
foreach (var f in migrationFields)
{
if (migrationFields.Last() == f)
{
Sql += f.Expresion + " FROM " + migrationTable.Tabla;
}
else
{
Sql += f.Expresion + " , ";
}
}
Sql += " " + migrationTable.Condicion;
GetDataTable(Sql);
laboratorio = null;
laboratorios = laboratorioController.SelectAll();
foreach (DataRow row in dataTable.Rows)
{
Ambiente.S1 = row["clave"].ToString().Trim().ToUpper();
Ambiente.S2 = row["descrip"].ToString().Trim().ToUpper();
laboratorio = laboratorios.FirstOrDefault(x => x.LaboratorioId.ToUpper().Equals(Ambiente.S1));
if (laboratorio == null)
{
laboratorio = new Laboratorio();
laboratorio.LaboratorioId = Ambiente.S1;
laboratorio.Nombre = Ambiente.S2;
laboratorio.IsDeleted = false;
laboratorioController.InsertOne(laboratorio);
}
else
{
laboratorio.Nombre = Ambiente.S2;
laboratorio.IsDeleted = false;
laboratorioController.Update(laboratorio);
}
}
Ambiente.Mensaje("Proceso concluido");
}
catch (Exception ex)
{
Ambiente.Mensaje(ex.ToString());
}
}
public List <Laboratorio> Eliminar(int idlaboratorio)
{
Laboratorio laboratorio = new Laboratorio
{
Idlaboratorio = idlaboratorio
};
context.Remove(laboratorio);
context.SaveChanges();
return(context.Laboratorio.ToList());
}
public ActionResult Create([Bind(Include = "LaboratorioID,NumClase,Capacidad")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Laboratorios.Add(laboratorio);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(laboratorio));
}
public void Update(Laboratorio l)
{
var resultado = context.Laboratorio.FirstOrDefault(x => x.Codigo_Laboratorio == l.Codigo_Laboratorio);
resultado.Direccion = l.Direccion;
resultado.Email = l.Email;
resultado.Estado = l.Estado;
resultado.Nombre = l.Nombre;
resultado.Telefono = l.Telefono;
context.SaveChanges();
}
public ActionResult SelectInstituciones(string hdnInstitucion, int idUsuario)
{
ViewBag.Locales = new Local {
IdInstitucion = int.Parse(hdnInstitucion)
};
ViewBag.instituciones = Session["Instituciones"] as List <Institucion>;
var local = new Local
{
IdInstitucion = int.Parse(hdnInstitucion),
IdUsuario = idUsuario
};
var bl = new LocalBl();
var disas = bl.GetDisas(local);
if (disas.Count == 1)
{
var idDisa = disas.First().IdDISA;
var redes = GetRedByDisa(hdnInstitucion, idDisa, idUsuario);
if (redes.Count == 1)
{
var idRed = redes.First().IdRed;
var microredes = GetMicroRedByRed(hdnInstitucion, idDisa, idRed + idDisa, idUsuario);
if (microredes.Count == 1)
{
var idMicroRed = microredes.First().IdMicroRed;
var establecimientos = GetEstablecimientoByMicroRed(hdnInstitucion, idDisa, idRed + idDisa, idMicroRed + idRed + idDisa, idUsuario);
SetEstablecimientoView(establecimientos);
}
SetMicroRedView(microredes);
}
SetRedView(redes);
}
SetDisaView(disas);
String ubigeo = Convert.ToString(Session["ubigeo"]);
Laboratorio LaboratorioUbigeo = new Laboratorio();
LaboratorioUbigeo.UbigeoLaboratorio = new Ubigeo();
LaboratorioUbigeo.UbigeoLaboratorio.Id = ubigeo;
ViewBag.LabUbigeo = LaboratorioUbigeo;
return(View("NuevoEESS"));
}
public bool EstaRelacionado(Laboratorio laboratorio)
{
try
{
return(_context.Medicamentos.Any(l => l.LaboratorioId == laboratorio.LaboratorioId));
}
catch (Exception)
{
throw new Exception("Error al verificar si està relacionado un Laboratorio");
}
}
public void CreateLaboratorio(Laboratorio laboratorio)
{
using (DbCommand command = Database.GetStoredProcCommand("[dbo].[SP_CREATE_LABORATORIO]"))
{
Database.AddInParameter(command, "@ID_FACULTAD", DbType.Int32, laboratorio.IdFacultad);
Database.AddInParameter(command, "@NOMBRE_LABORATORIO", DbType.String, laboratorio.NombreLaboratorio);
Database.AddInParameter(command, "@ESTADO", DbType.String, laboratorio.Estado);
Database.ExecuteNonQuery(command);
}
}
public ActionResult Edit([Bind(Include = "LaboratorioId,Nome,Capacidade,Status,DataCadastro,BlocoId")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
var laboratorioBo = new LaboratorioBo();
laboratorioBo.Editar(laboratorio);
return(RedirectToAction("Index"));
}
ViewBag.BlocoId = new SelectList(db.Blocos, "BlocoId", "Nome", laboratorio.BlocoId);
return(View(laboratorio));
}
public ActionResult Create([Bind(Include = "Id,Nombre,Email,Direccion")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Laboratorio.Add(laboratorio);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(laboratorio));
}
public async Task <IActionResult> Create([Bind("ID,Nome,Campus,Tipo")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
_context.Add(laboratorio);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(laboratorio));
}
public static List <Laboratorista> ListarLaboratoristas()
{
SqlConnection sqlCon = new SqlConnection();
//Lista de alumnos
List <Laboratorista> laboratoristas = new List <Laboratorista>();
try
{
sqlCon = Conexion.getInstancia().CrearConexion(); //Utilizamos la variable tipo sql connection que obtenemos desde la clase conexion
sqlCon.Open();
SqlCommand cmd = new SqlCommand("SELECT E.idLaboratorista, E.claveLaboratorista, E.turno, P.nombre, P.apPaterno, P.apMaterno, L.idLaboratorio, L.claveLaboratorio, L.nombre FROM Laboratorista E INNER JOIN Persona P ON (E.idPersona = P.idPersona) INNER JOIN Laboratorio L ON (E.idLaboratorio = L.idLaboratorio) WHERE E.estatus = 1", sqlCon);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Laboratorio l = new Laboratorio();
Persona p = new Persona();
Laboratorista e = new Laboratorista();
e.idLaboratorista = reader.GetInt32(0);
e.claveLaboratorista = reader.GetString(1);
e.turno = reader.GetString(2);
p.nombre = reader.GetString(3);
p.apPaterno = reader.GetString(4);
p.apMaterno = reader.GetString(5);
l.IdLaboratorio = reader.GetInt32(6);
l.ClaveLaboratorio = reader.GetString(7);
l.Nombre = reader.GetString(8);
e.Persona = p;
e.Laboratorio = l;
laboratoristas.Add(e);
}
}
}
catch (Exception e)
{
throw e;
}
finally
{ // Este codigo se va a ejecutar aunque haya alguna excepcion. **SIEMPRE SE CERRARÁ LA CONEXIÓN**
if (sqlCon.State == ConnectionState.Open)
{
sqlCon.Close();
}
}
return(laboratoristas);
}
public Laboratorio Build()
{
var laboratorioFake = new Laboratorio(_nome, _endereco, _status);
if (_id > 0)
{
var propertyInfo = laboratorioFake.GetType().GetProperty("Id");
propertyInfo.SetValue(laboratorioFake, Convert.ChangeType(_id, propertyInfo.PropertyType), null);
}
return(laboratorioFake);
}
public MuestraRegistrada ActualizarMuestra(MuestraActualizada muestraActualizada)
{
using (Laboratorio laboratorio = new Laboratorio())
{
Muestras muestra = laboratorio.Muestras.Find(muestraActualizada.Id);
muestra.Id = muestraActualizada.Id;
muestra.NombreDeLaPersonaMuestrada = muestraActualizada.NombreDeLaPersonaMuestrada;
muestra.FechaDeLaToma = muestraActualizada.FechaDeLaToma;
muestra.NombreDeLaPersonaQueTomaLaMuestra = muestraActualizada.NombreDeLaPersonaQueTomaLaMuestra;
return(ConvertirMuestrasA_DTO(muestra));
}
}
public bool Existe(LaboratorioEditDto laboratorioDto)
{
try
{
Laboratorio laboratorio = _mapper.Map <Laboratorio>(laboratorioDto);
return(_repositorio.Existe(laboratorio));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult Editar(Laboratorio laboratorio)
{
if (SecurityHelper.GetAdministradorID() > 0 && (SecurityHelper.GetAdministradorRol() == "Administrador General" || SecurityHelper.GetAdministradorRol() == "Técnico"))
{
laboratorioDataAccess.UpdateLaboratorio(laboratorio);
return(RedirectToAction("Index", "Laboratorio", new { Area = "" }));
}
else
{
return(RedirectToAction("Index", "Login", new { Area = "" }));
}
}
public static int acutalizarLaboratorio(Laboratorio l)
{
int respuesta = 0;
SqlConnection sqlConnection = new SqlConnection();
try
{
sqlConnection = Conexion.getInstancia().CrearConexion();
SqlCommand command = new SqlCommand("sp_actualizarLaboratorio", sqlConnection);
command.CommandType = CommandType.StoredProcedure;
//Agregamos los parametros:
command.Parameters.Add("@var_idLaboratorio", SqlDbType.Int).Value = l.IdLaboratorio;
command.Parameters.Add("@var_nombre", SqlDbType.VarChar).Value = l.Nombre;
command.Parameters.Add("@var_estatus", SqlDbType.Int).Value = 1;
//Agregamos los parametros de salida (claveLaboratorio)
SqlParameter var_salidaConfirmacion = new SqlParameter();
var_salidaConfirmacion.ParameterName = "@var_salidaConfirmacion";
var_salidaConfirmacion.SqlDbType = SqlDbType.Int;
var_salidaConfirmacion.Direction = ParameterDirection.Output;
command.Parameters.Add(var_salidaConfirmacion);
//Abrimos la conexion y guardamos el resultado en respuesta
sqlConnection.Open();
if (command.ExecuteNonQuery() >= 1) // el 1 respresenta un resultado exitoso
{
//Esto quiere decir que se ingresó el provedor correctamente
respuesta = 1;
}
else
{
respuesta = 0;
}
}
catch (Exception e)
{
throw e;
}
finally
{
if (sqlConnection.State == ConnectionState.Open)
{
sqlConnection.Close();
}
}
return(respuesta);
}
public ActionResult Edit([Bind(Include = "Id,Nome,Localizacao,EmpresaQuimicoId")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Entry(laboratorio).State = EntityState.Modified;
db.SaveChanges();
TempData["MSG"] = "success|Edição realizada";
return(RedirectToAction("Index"));
}
TempData["MSG"] = "Warning|Edição não realizada";
ViewBag.EmpresaQuimicoId = new SelectList(db.EmpresaQuimico, "Id", "NomeEmpresa", laboratorio.EmpresaQuimicoId);
return(View(laboratorio));
}
private void btnEliminarLaboratorio_Click(object sender, EventArgs e)
{
Laboratorio laboratorio = new Laboratorio();
//laboratorioBindingSource.EndEdit();
laboratorioBindingSource.EndEdit();
laboratorio = (Laboratorio)laboratorioBindingSource.Current;
cLaboratorio.EliminarLaboratorio(laboratorio);
laboratorioBindingSource.DataSource = cLaboratorio.Consultar();
}
public ActionResult Create([Bind(Include = "Id,Nome,Localizacao,EmpresaQuimicoId")] Laboratorio laboratorio)
{
if (ModelState.IsValid)
{
db.Laboratorio.Add(laboratorio);
db.SaveChanges();
TempData["MSG"] = "success|Cadastro realizado";
return(RedirectToAction("Index"));
}
TempData["MSG"] = "Warning|Cadastro não realizado";
ViewBag.EmpresaQuimicoId = new SelectList(db.EmpresaQuimico, "Id", "NomeEmpresa", laboratorio.EmpresaQuimicoId);
return(View(laboratorio));
}
public void inserirLaboratorio(Laboratorio laboratorio)
{
inserirPessoaJuridica(laboratorio);
laboratorio.id = Convert.ToInt32(consultaPessoaJuridica("select top 1 ID_PESSOA_JURIDICA from PESSOA_JURIDICA order by ID_PESSOA_JURIDICA desc").Rows[0][0].ToString());
using (OdbcConnection conexao = ConexaoPadrao.createConnection())
{
string sql = "insert into LABORATORIO (ID_PESSOA_JURIDICA) values(?)";
OdbcCommand command = new OdbcCommand(sql, conexao);
command.Parameters.AddWithValue("@ID_PESSOA_JURIDICA", laboratorio.id);
conexao.Open();
command.ExecuteNonQuery();
}
}
public virtual ActionResult Crear()
{
try
{
var entidad = new Laboratorio
{
LAB_Nombre = string.Empty
};
PrepararDatos(ref entidad, "Crear");
return PartialView("Edit", entidad);
}
catch (Exception ex)
{
logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
return new HttpNotFoundWithViewResult("Error");
}
}
public void AdicionaLabDescarteDireto(Laboratorio lab)
{
XElement x = new XElement("PkIdLaboratorio");
x.Add(lab.PkIdLaboratorio);
XElement xml = XElement.Load(CaminhoPastaXML());
xml.Add(x);
xml.Save(CaminhoPastaXML());
}
private void PrepararDatos(ref Laboratorio entidad, string accion)
{
entidad.Accion = accion;
ViewData["idMenu"] = this.IdMenu;
entidad.IdMenu = this.IdMenu;
entidad.IdModulo = this.IdModulo;
entidad.Estados = Utils.EnumToList<TipoEstado>();
}
public List<Laboratorio> ListarLabsDescarteDireto()
{
List<Laboratorio> labsDescarteDireto = new List<Laboratorio>();
if (File.Exists(CaminhoPastaXML()))
{
try
{
XElement xml = XElement.Load(CaminhoPastaXML());
foreach (XElement x in xml.Elements())
{
if (!string.IsNullOrEmpty(x.Value.Trim()))
{
Laboratorio lab = new Laboratorio()
{
PkIdLaboratorio = int.Parse(x.Value.Trim()),
};
labsDescarteDireto.Add(lab);
}
}
}
catch (Exception ex) { }//Caso o arquivo seja apagado não será exibido um erro
}
return labsDescarteDireto;
}
protected void ckbDescarteDireto_CheckedChanged(object sender, EventArgs e)
{
try
{
foreach (RepeaterItem item in rptCadastros.Items)
{
Label lblIdCadastro = (Label)item.FindControl("lblIdCadastro");
CheckBox ckbDescarteDireto = (CheckBox)item.FindControl("ckbDescarteDireto");
if (!string.IsNullOrEmpty(lblIdCadastro.Text))
{
if (ckbDescarteDireto.Checked)
{
List<Laboratorio> labsDD = ListarLabsDescarteDireto();
labsDD = labsDD.Where(x => x.PkIdLaboratorio.ToString() == lblIdCadastro.Text.Trim()).ToList();
if (labsDD.Count <= 0)
{
Laboratorio lab = new Laboratorio()
{
PkIdLaboratorio = Convert.ToInt32(lblIdCadastro.Text.Trim()),
};
AdicionaLabDescarteDireto(lab);
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox", "alert('Laboratório inserido no Descarte Direto com sucesso!');", true);
}
}
else
{
List<Laboratorio> labsDD = ListarLabsDescarteDireto();
labsDD = labsDD.Where(x => x.PkIdLaboratorio.ToString() == lblIdCadastro.Text.Trim()).ToList();
if (labsDD.Count > 0)
{
for (int idLab = 0; idLab < labsDD.Count; idLab++)
{
if (!string.IsNullOrEmpty(labsDD[idLab].PkIdLaboratorio.ToString()) && labsDD[idLab].PkIdLaboratorio != 0)
{
ExcluirLabDescarteDireto(labsDD[idLab].PkIdLaboratorio);
}
}
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox", "alert('Laboratório removid do Descarte Direto com sucesso!');", true);
}
}
DesmarcaSelecionados();
}
}
}
catch (Exception ex)
{
Page.ClientScript.RegisterStartupScript(GetType(), "msgbox",
"alert('Ocorreu um erro e não foi possível </ br> incluir o Laboratório no Descarte Direto!');", true);
}
}
