/// <summary>
/// Autor: Jesus Torres
/// 19/nov/19
/// Este método retorna una lista con todos los Concursos Disponibles.
/// </summary>
/// <returns>List<Funcionario></returns>
public List <Concurso> ListarConcursos()
{
List <Concurso> concursos = new List <Concurso>();
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_ConsultarConcursos", sqlConnection);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Concurso concurso;
while (reader.Read())
{
concurso = new Concurso();
concurso.idConcurso = Convert.ToInt32(reader["TN_IdConcurso"]);
concurso.NombreConcurso = reader["TC_NombreConcurso"].ToString();
concurso.FechaConcurso = Convert.ToDateTime(reader["TF_FechaIngresoConcurso"]).Date;
Puesto puesto = new Puesto();
puesto.Nombre = reader["TC_NombreClasePuesto"].ToString();
puesto.IdPuesto = Convert.ToInt32(reader["TN_IdPuesto"]);
concurso.Puesto = puesto;
concursos.Add(concurso);
}
sqlConnection.Close();
return(concursos);
}
/// <summary>
/// Autor: Jesus Torres
/// 19/nov/19
/// Este método retorna una lista con todos los Concursos que opta un funcionario
/// </summary>
/// <returns>List<Funcionario></returns>
public List <Concurso> ListarConcursosPorFuncionario(string cedula)
{
List <Concurso> concursos = new List <Concurso>();
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_ConsultarConcursosOptaFuncionario @cedula", sqlConnection);
sqlCommand.Parameters.AddWithValue("@cedula", cedula);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Concurso concurso;
while (reader.Read())
{
concurso = new Concurso();
concurso.idConcurso = Convert.ToInt32(reader["TN_IdConcurso"]);
concurso.NombreConcurso = reader["TC_NombreConcurso"].ToString();
concurso.FechaConcurso = Convert.ToDateTime(reader["TF_FechaIngresoConcurso"]).Date;
Puesto puesto = new Puesto();
puesto.Nombre = reader["NombrePuesto"].ToString();
concurso.Puesto = puesto;
concursos.Add(concurso);
}
sqlConnection.Close();
return(concursos);
}
public ActionResult Edit(Puesto puesto)
{
try
{
var objeto = new Puesto
{
Accion = "ACTUALIZAR",
IdPuesto = puesto.IdPuesto,
IdDepartamento = puesto.IdDepartamento,
Alias = puesto.Alias,
Descripcion = puesto.Descripcion,
Estado = puesto.Estado,
UsuarioCreacion = puesto.UsuarioCreacion,
FechaCreacion = puesto.FechaCreacion,
UsuarioModificacion = User.Identity.Name,
FechaModificacion = DateTime.Now
};
var dt = _servicio.ProcesarPuestos(objeto);
if (dt.IsSuccess)
{
return(RedirectToAction("Index"));
}
else
{
return(View("Edit"));
}
}
catch
{
return(View());
}
}
public void Actualizar(int idPuesto, Puesto puesto)
{
DataBaseModelContext db = new DataBaseModelContext();
try
{
db.ContextOptions.LazyLoadingEnabled = true;
Puesto pto = db.Puesto.SingleOrDefault(s => s.Id == idPuesto);
if (pto == null)
{
return;
}
pto.Descripcion = puesto.Descripcion.Trim().ToUpper();
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception((ex.InnerException).Message);
}
finally
{
db.Dispose();
}
}
public frmDatosPuesto(int id)
{
InitializeComponent();
t = new Puesto();
t.ID = id;
editar = true;
}
/// <summary>
/// Autor: Jesus Torres
/// 26/nov/19
/// Este método retorna un concurso por su ID
/// </summary>
public Concurso ObtieneConcursoPorId(int idConcurso)
{
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_ConsultarConcursoPorID @TN_IdConcurso", sqlConnection);
sqlCommand.Parameters.AddWithValue("@TN_IdConcurso", idConcurso);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Concurso concurso = new Concurso();
while (reader.Read())
{
concurso.idConcurso = Convert.ToInt32(reader["TN_IdConcurso"]);
concurso.NombreConcurso = reader["TC_NombreConcurso"].ToString();
concurso.FechaConcurso = Convert.ToDateTime(reader["TF_FechaIngresoConcurso"]).Date;
Puesto puesto = new Puesto();
puesto.Nombre = reader["TC_NombreClasePuesto"].ToString();
puesto.IdPuesto = Convert.ToInt32(reader["TN_IdPuesto"].ToString());
concurso.Puesto = puesto;
}
sqlConnection.Close();
return(concurso);
}
/// <summary>
/// Jesús Torres
/// 24/oct/2019
/// Efecto: Este método retorna una lista con todos los Puestos de una persona y su condicion
/// Requiere: La cedula a consultar y la condicion de los puestos que se desean consultar
/// Modifica:
/// <returns>IEnumerable<PrimerIngresoElegibles></returns>
/// </summary>
public IEnumerable <Puesto> CosultarPuestos(string cedula, int condicionPuesto)
{
List <Puesto> puestos = new List <Puesto>();
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_PrimerIngresoPuestoAplicaPorCondicion @Cedula, @condicion", sqlConnection);
sqlCommand.Parameters.AddWithValue("@Cedula", cedula);
sqlCommand.Parameters.AddWithValue("@condicion", condicionPuesto);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Puesto puesto;
while (reader.Read())
{
puesto = new Puesto();
puesto.Nombre = reader["TC_NombreClasePuesto"].ToString();
puesto.IdPuesto = Convert.ToInt32(reader["TN_IdPuesto"].ToString());
puesto.Condicion = reader["Condicion"].ToString();
puestos.Add(puesto);
}
sqlConnection.Close();
return(puestos);
}
public async Task <IActionResult> Update(Int64 Id, Puesto _PuestoP)
{
Puesto _Puesto = _PuestoP;
try
{
string baseadress = config.Value.urlbase;
HttpClient _client = new HttpClient();
_client.DefaultRequestHeaders.Add("Authorization", "Bearer " + HttpContext.Session.GetString("token"));
_Puesto.FechaModificacion = DateTime.Now;
_Puesto.Usuariomodificacion = HttpContext.Session.GetString("user");
var result = await _client.PutAsJsonAsync(baseadress + "api/Puesto/Update", _Puesto);
string valorrespuesta = "";
if (result.IsSuccessStatusCode)
{
valorrespuesta = await(result.Content.ReadAsStringAsync());
_Puesto = JsonConvert.DeserializeObject <Puesto>(valorrespuesta);
}
}
catch (Exception ex)
{
return(BadRequest($"Ocurrio un error{ex.Message}"));
}
return(new ObjectResult(new DataSourceResult {
Data = new[] { _Puesto }, Total = 1
}));
}
public async Task <ActionResult <Puesto> > Delete([FromBody] Puesto _puesto)
{
try
{
string baseadress = config.Value.urlbase;
HttpClient _client = new HttpClient();
_client.DefaultRequestHeaders.Add("Authorization", "Bearer " + HttpContext.Session.GetString("token"));
var result = await _client.PostAsJsonAsync(baseadress + "api/Puesto/Delete", _puesto);
string valorrespuesta = "";
if (result.IsSuccessStatusCode)
{
valorrespuesta = await(result.Content.ReadAsStringAsync());
_puesto = JsonConvert.DeserializeObject <Puesto>(valorrespuesta);
if (_puesto.IdPuesto == 0)
{
return(await Task.Run(() => BadRequest($"No se puede eliminar el Puesto porque ya esta siendo usada.")));
}
}
}
catch (Exception ex)
{
_logger.LogError($"Ocurrio un error: { ex.ToString() }");
return(BadRequest($"Ocurrio un error: {ex.Message}"));
}
//return Ok(_VendorType);
return(new ObjectResult(new DataSourceResult {
Data = new[] { _puesto }, Total = 1
}));
}
public async Task <HttpResponseMessage> DeletePuesto(IdModelPuesto id)
{
try
{
_puesto = await db.Puesto.FindAsync(id.IdPuesto);
if (_puesto == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
_puesto.Activo_Inactivo = false;
db.Entry(_puesto).State = EntityState.Modified;
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
/// <summary>
/// Propósito: Método Insertar de la clase de negocios. Este método inserta una fila nueva en la base de datos.
/// </summary>
/// <returns>True si tuvo éxito, sino genera una Exception. </returns>
/// <remarks>
/// Propiedades necesarias para este método:
/// <UL>
/// <LI>AnnoInicial</LI>
/// <LI>AnnoFinal</LI>
/// <LI>Empresa</LI>
/// <LI>Puesto</LI>
/// <LI>FK_IdPersona</LI>
/// </UL>
/// Propiedades actualizadas luego de una llamada exitosa a este método:
/// <UL>
/// <LI>Id_ExperienciaLaboral</LI>
/// <LI>CodError</LI>
/// </UL>
/// </remarks>
public override bool Insertar()
{
string operacion;
//SeguridadSoapClient wsseg = new SeguridadSoapClient();
try
{
//Construir aqui el string a guardar en la bitacora.
operacion = "Insertar cIATExperienciaLaboral;"
+ "AnnoInicial:" + AnnoInicial.ToString() + ";"
+ "AnnoFinal:" + AnnoFinal.ToString() + ";"
+ "Empresa:" + Empresa.ToString() + ";"
+ "Puesto:" + Puesto.ToString() + ";"
+ "FK_IdPersona:" + FK_IdPersona.ToString() + ";";
//wsseg.BitacoraRegistrarUso(_COD_APLICACIONBitacora, _COD_FUNCIONALIDADBitacora, _COD_SEDEBitacora, eTipoEventoBitacora.UsoFuncionalidad, _ID_USUARIOBitacora,operacion);
return(base.Insertar());
}
catch (Exception ex)
{
//Construir el string a guardar en la bitácora en caso de error.
operacion = "Error Insertar cIATExperienciaLaboral;" + ex.Message;
//wsseg.BitacoraRegistrarUso(_COD_APLICACIONBitacora, _COD_FUNCIONALIDADBitacora, _COD_SEDEBitacora, eTipoEventoBitacora.Error, _ID_USUARIOBitacora,operacion);
throw ex;
}
}
/// <summary>
/// Jesús Torres
/// 24/oct/2019
/// Efecto: Este método retorna una lista con todos los Puestos
/// Requiere:
/// Modifica:
/// <returns>IEnumerable<PrimerIngresoElegibles></returns>
/// </summary>
public IEnumerable <Puesto> ListarPuestos()
{
List <Puesto> puestos = new List <Puesto>();
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_ConsultarPuestos", sqlConnection);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Puesto puesto;
while (reader.Read())
{
puesto = new Puesto();
puesto.Nombre = reader["TC_NombreClasePuesto"].ToString();
puesto.IdPuesto = Convert.ToInt32(reader["TN_IdPuesto"].ToString());
puestos.Add(puesto);
}
sqlConnection.Close();
return(puestos);
}
public async Task <IActionResult> Edit(int id, [Bind("puestoID,nombrePuesto")] Puesto puesto)
{
if (id != puesto.puestoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(puesto);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PuestoExists(puesto.puestoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(puesto));
}
public void UpdatePuesto(ref Puesto oPuesto)
{
string sMensaje = string.Empty;
Database db = EnterpriseLibraryContainer.Current.GetInstance <Database>("Inventario");
StringBuilder sqlCommand = new StringBuilder();
sqlCommand.AppendLine("UPDATE pUESTO ");
sqlCommand.AppendLine("SET Descripcion = @pDescripcion ");
sqlCommand.AppendLine(" , Estatus = @pEstatus ");
sqlCommand.AppendLine("WHERE idPuesto = @pidPuesto");
DbCommand dbCommand = db.GetSqlStringCommand(sqlCommand.ToString());
db.AddInParameter(dbCommand, "@pDescripcion", DbType.String, oPuesto.descripcion);
db.AddInParameter(dbCommand, "@pEstatus", DbType.Boolean, oPuesto.estatus == "ACTIVO" ? 1 : 0);
db.AddInParameter(dbCommand, "@pidPuesto", DbType.Int32, oPuesto.idPuesto);
try
{
db.ExecuteNonQuery(dbCommand);
}
catch (DataException ex)
{
throw ex;
}
}
// Obtener un puesto
public string getPuesto(Puesto _puesto)
{
Puesto puesto = null;
try
{
SqlDataReader dr = consultar("EXEC sp_get_puesto '" + _puesto.TN_Id_Puesto + "'");
if (dr != null)
{
while (dr.Read())
{
puesto = new Puesto();
puesto.TN_Id_Puesto = int.Parse(dr["TN_Id_Puesto"].ToString());
puesto.TC_Nombre_Puesto = dr["TC_Nombre_Puesto"].ToString();
puesto.TN_Salario_Horario = int.Parse(dr["TN_Salario_Horario"].ToString());
}
}
}
catch (SqlException e)
{
Console.WriteLine(e.ToString());
puesto = null;
}
this.closeCon();
return(JsonConvert.SerializeObject(puesto));
}
public Response <Puesto> Insert(Puesto datos)
{
Response <Puesto> response = new Response <Puesto>();
try
{
if (datos.NombrePuesto.IsNullOrEmpty())
{
return(response.Error("Nombre es obligatorio"));
}
if (datos.NombrePuesto.IsNullOrEmpty())
{
return(response.Error("Nombre es obligatorio"));
}
if (puestoRepository.GetByName(datos.NombrePuesto) != null)
{
return(response.Error("El nombre ya existe"));
}
datos.FechaCreacion = BaseRepository.GetServerDateTime();
puestoRepository.Insert(datos);
return(response);
}
catch (Exception e)
{
return(response.Error(e.Message));
}
}
public ActionResult CreatePuesto(PuestoVM oPuestoVM)
{
Puesto oPuesto = oPuestoVM.Puesto;
var dbSetPuestos = _db.Puestos;
var lPuestos = (from p in dbSetPuestos
where p.IdPuesto == oPuesto.IdPuesto
select p).ToList();
if (lPuestos.Count > 0)
{
return(View("~/Views/RH/Puestos/Create.cshtml", oPuestoVM));
}
else
{
oPuesto.Estado = "A";
if (ModelState.IsValid)
{
dbSetPuestos.Add(oPuesto);
_db.SaveChanges();
}
else
{
oPuestoVM.ListaDepartamentos = listaDepartamentos();
return(View("~/Views/RH/Puestos/Create.cshtml", oPuestoVM));
}
}
return(RedirectToRoute(new { controller = "RH", action = "Puestos" }));
}
public async Task <HttpResponseMessage> GetPuesto(IdModelPuesto id)
{
try
{
_puesto = await db.Puesto.FindAsync(id.IdPuesto);
if (_puesto == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(_puesto), System.Text.Encoding.UTF8, "application/json")
});
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
public async Task <HttpResponseMessage> PutPuesto(Puesto Puesto)
{
try
{
_puesto = await db.Puesto.FindAsync(Puesto.IdPuesto);
if (_puesto == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
_puesto.IdUbicacion = Puesto.IdUbicacion;
_puesto.IdArea = Puesto.IdArea;
_puesto.NombrePuesto = Puesto.NombrePuesto;
_puesto.Descripcion = Puesto.Descripcion;
_puesto.CostoHora = Puesto.CostoHora;
_puesto.Salario = Puesto.Salario;
_puesto.HorasMes = Puesto.HorasMes;
_puesto.Activo_Inactivo = Puesto.Activo_Inactivo;
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
public async Task <IActionResult> PutPuesto(int id, Puesto puesto)
{
if (id != puesto.PuestoId)
{
return(BadRequest());
}
_context.Entry(puesto).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PuestoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> OnPostDeleteTecnicoAsync(int id, int TecnicoToDeleteID)
{
Puesto PuestoToUpdate = await _context.Puesto
.Include(a => a.TecnicosSugeridosPuesto)
.ThenInclude(a => a.Tecnico)
.FirstOrDefaultAsync(m => m.ID == id);
await TryUpdateModelAsync <Puesto>(PuestoToUpdate);
var TecnicoToDelete = PuestoToUpdate.TecnicosSugeridosPuesto.Where(a => a.TecnicoID == TecnicoToDeleteID).FirstOrDefault();
if (TecnicoToDelete != null)
{
PuestoToUpdate.TecnicosSugeridosPuesto.Remove(TecnicoToDelete);
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PuestoExists(Puesto.ID))
{
return(NotFound());
}
else
{
throw;
}
}
ControlarCambioEstado(id);
return(Redirect(Request.Path + $"?id={id}"));
}
static public void proponerEquipo(Sector sec, int nivel, bool puestoFijo = true)
{
if (sec.jefe == null)
{
List <UsuarioPropuesto> newBossList = obtener(sec, 1, nivel, null, true, null, puestoFijo);
if (newBossList.Count > 0)
{
sec.jefe = newBossList[0];
}
}
foreach (KeyValuePair <Puesto, Usuario> position in sec.puestos.ToList())
{
if (position.Value == null)
{
List <UsuarioPropuesto> newUserList = obtener(sec, 1, nivel, position.Key, false, null, puestoFijo);
if (newUserList.Count == 0)
{
continue;
}
Puesto newPuesto = PuestoManager.obtener(sec.puestos.FindAll(p => p.Key == position.Key && p.Value == null)[0].Key.id);
sec.puestos.Remove(sec.puestos.FindAll(p => p.Key == position.Key && p.Value == null)[0]);
sec.puestos.Add(new KeyValuePair <Puesto, Usuario>(newPuesto, newUserList[0]));
}
}
return;
}
public void Guardar(Puesto puesto)
{
DataBaseModelContext db = new DataBaseModelContext();
try
{
puesto.Habilitado = true;
puesto.Descripcion = puesto.Descripcion.Trim();
if (db.Puesto.Any(a => a.Descripcion == puesto.Descripcion && a.IdTipoUsuario == puesto.IdTipoUsuario))
{
throw new Exception("Este Puesto ya existe.");
}
if (puesto.Id == 0)
{
db.Puesto.AddObject(puesto);
}
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
db.Dispose();
}
}
public List <Trabajador> GetLista(Puesto puesto)
{
List <Trabajador> trabajadores = null;
try
{
using (RestaurantEntities context = new RestaurantEntities())
{
context.Configuration.LazyLoadingEnabled = false;
if (puesto == null)
{
trabajadores = context.Trabajador.Include(t => t.Puesto).OrderBy(t => t.apellidos).ThenBy(t => t.nombre).ToList();
}
else
{
trabajadores = context.Trabajador.Where(t => t.id_puesto == puesto.id_puesto).Include(t => t.Puesto).OrderBy(t => t.apellidos).ThenBy(t => t.nombre).ToList();
}
}
return(trabajadores);
}
catch (Exception e)
{
Log.Write("Error " + e.Message);
return(trabajadores);
}
}
private async Task BitacoraAsync(string accion, Puesto puesto, string excepcion = "")
{
string directorioBitacora = _configuration.GetValue <string>("DirectorioBitacora");
await _getHelper.SetBitacoraAsync(token, accion, moduloId,
puesto, puesto.PuestoID.ToString(), directorioBitacora, excepcion);
}
public void Actualizar(int idPuesto, Puesto puesto)
{
DataBaseModelContext db = new DataBaseModelContext();
try
{
if (db.Puesto.Any(a => a.Descripcion == puesto.Descripcion && a.IdTipoUsuario == puesto.IdTipoUsuario && a.Id != idPuesto))
{
throw new Exception("Este Puesto ya existe.");
}
db.ContextOptions.LazyLoadingEnabled = true;
Puesto pto = db.Puesto.SingleOrDefault(s => s.Id == idPuesto);
if (pto == null)
{
return;
}
pto.Descripcion = puesto.Descripcion.Trim();
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
db.Dispose();
}
}
public async Task <IActionResult> Create([Bind("PuestoID,PuestoNombre,PuestoDescripcion")] Puesto puesto)
{
var validateToken = await ValidatedToken(_configuration, _getHelper, "catalogo");
if (validateToken != null)
{
return(validateToken);
}
if (!await ValidateModulePermissions(_getHelper, moduloId, eTipoPermiso.PermisoEscritura))
{
return(RedirectToAction(nameof(Index)));
}
TempData["toast"] = "Falta información en algún campo, verifique.";
if (ModelState.IsValid)
{
puesto.PuestoID = Guid.NewGuid();
_context.Add(puesto);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(puesto));
}
public async Task <IHttpActionResult> PutPuesto(int id, Puesto puesto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != puesto.id)
{
return(BadRequest());
}
db.Entry(puesto).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PuestoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <ActionResult <Puesto> > PostPuesto(Puesto puesto)
{
_context.Puesto.Add(puesto);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPuesto", new { id = puesto.PuestoId }, puesto));
}
public async Task <ActionResult> Delete(int?id)
{
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Puesto puesto = await db.Puestos.FindAsync(id);
if (puesto == null)
{
return(HttpNotFound());
}
db.Puestos.Remove(puesto);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// elimina una Puesto
/// </summary>
/// <param name="dato"></param>
public void eliminar(Puesto dato)
{
if (this.existe(dato))
{
this.puestoDA.eliminar(dato);
}
else
{
throw new Exception("No existe el registro.");
}
}
/// <summary>
/// consulta una Puesto
/// </summary>
/// <param name="dato"></param>
/// <returns></returns>
public Puesto consultarId(Puesto dato)
{
return this.puestoDA.consultarId(dato);
}
/// <summary>
/// crea una Puesto nuevo
/// </summary>
/// <param name="dato"></param>
public void nuevo(Puesto dato)
{
if (!this.existe(dato))
{
this.puestoDA.nuevo(dato);
}
else
{
throw new Exception("Ya existe el registro.");
}
}
/// <summary>
/// verifica si existe una Puesto
/// </summary>
/// <param name="dato"></param>
/// <returns>TRUE si existe FALSE en caso contrario</returns>
public bool existe(Puesto dato)
{
return this.puestoDA.existe(dato);
}
/// <summary>
/// inserta un registro nuevo
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ASPxGridView1_RowInserting(object sender, DevExpress.Web.Data.ASPxDataInsertingEventArgs e)
{
try
{
Puesto puesto = new Puesto();
//llena el objeto con los valores
puesto.descripcion = e.NewValues["descripcion"].ToString();
puesto.usuarioCreacion = Session["usuario"].ToString();
puesto.estado = e.NewValues["estado"].ToString();
puestoBL.nuevo(puesto);//agrega el objeto a la base de datos
e.Cancel = true;//manejo de execpcion no controlada BUSCAR SOLUCION
this.ASPxGridView1.CancelEdit();
this.cargarDatos();//refescar los datos
}
catch (Exception ex)
{
Session["errorMessage"] = ex.Message;
}
}
