public async Task <IActionResult> Edit(int id, [Bind("Id,NombreEmpresa,Puesto,Responsabilidad,FechaInicio,FechaFinalizacion")] ExperienciaLaboral experienciaLaboral)
{
if (id != experienciaLaboral.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(experienciaLaboral);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExperienciaLaboralExists(experienciaLaboral.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(experienciaLaboral));
}
public IActionResult Edit(ExperienciaLaboral experienciaLaboral)
{
int?id = experienciaLaboral.Candidato;
sv.Actualizar(experienciaLaboral);
return(RedirectToAction("Index", "Home", new { id = id }));
}
public void Nuevo(ExperienciaLaboral experiencias, int idCandidato)
{
experiencias.Candidato = idCandidato;
experiencias.Id = NuevoCodigo();
DB.ExperienciaLaboral.Add(experiencias);
DB.SaveChanges();
}
public async Task <IActionResult> Create([Bind("Id,NombreEmpresa,Puesto,Responsabilidad,FechaInicio,FechaFinalizacion")] ExperienciaLaboral experienciaLaboral)
{
if (ModelState.IsValid)
{
_context.Add(experienciaLaboral);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(experienciaLaboral));
}
public IActionResult Update(string id, ExperienciaLaboral experienciaLaboralIn)
{
var model = collectionServices.Get(id);
if (model == null)
{
return(NotFound());
}
collectionServices.Update(id, experienciaLaboralIn);
return(NoContent());
}
private async void button1_Click(object sender, EventArgs e)
{
if (!String.IsNullOrWhiteSpace(NombreTxtBox.Text) &&
!String.IsNullOrWhiteSpace(SalarioTxtBox.Text) &&
!String.IsNullOrWhiteSpace(IntitucionComboBox.Text) &&
!String.IsNullOrWhiteSpace(Convert.ToString(fechaDesde.Value)) &&
!String.IsNullOrWhiteSpace(Convert.ToString(fechaHasta.Value)))
{
showLoading();
string accionRealizada;
var institucion = (Institucion)IntitucionComboBox.SelectedItem;
var entity = new ExperienciaLaboral()
{
Id = _rowSelectedId,
InstitucionId = institucion.Id,
FechaDesde = fechaDesde.Value,
FechaHasta = fechaHasta.Value,
PuestoOcupado = NombreTxtBox.Text,
Salario = Convert.ToDecimal(SalarioTxtBox.Text),
UserId = CurrentUser.Id
};
if (_rowSelectedId == 0)
{
if (await _experienciaLaboralService.ValidateIfExist(entity.PuestoOcupado, entity.InstitucionId))
{
MessageBox.Show("Ya se ha creado esa experiencia en ese puesto en esa institucion", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Warning);
hideLoading();
return;
}
accionRealizada = "creado";
}
else
{
accionRealizada = "editado";
}
await _experienciaLaboralService.AddOrUpdateAsync(entity);
MessageBox.Show("Se ha " + accionRealizada + " la experiencia laboral correctamente", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Information);
update_dataGridView();
cleanModel();
hideLoading();
}
else
{
MessageBox.Show("Debe llenar todos los campos", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
/// <summary>
/// Edita la información de la experiencia laboral de un usuario registrado
/// </summary>
/// <param name="datos"></param>
/// <returns></returns>
public bool Actualizar(ExperienciaLaboral datos)
{
var actualizar = BD.ExperienciaLaboral.FirstOrDefault(x => x.ExperienciaLaboralId == datos.ExperienciaLaboralId);
actualizar.Puesto = datos.Puesto;
actualizar.UsuarioId = datos.UsuarioId;
actualizar.Descripcion = datos.Descripcion;
actualizar.FechaDesde = datos.FechaDesde;
actualizar.FechaHasta = datos.FechaHasta;
actualizar.ReferenciaNombre = datos.ReferenciaNombre;
actualizar.ReferenciaTelefono = datos.ReferenciaTelefono;
actualizar.Actualidad = datos.Actualidad;
return(BD.SaveChanges() > 0);
}
public static ExperienciaLaboralDTO ToDTO(this ExperienciaLaboral model)
{
return(new ExperienciaLaboralDTO
{
ExperienciaLaboralId = model.ExperienciaLaboralId,
UsuarioId = model.UsuarioId,
Puesto = model.Puesto,
Descripcion = model.Descripcion,
FechaDesde = model.FechaDesde,
FechaHasta = model.FechaHasta,
ReferenciaNombre = model.ReferenciaNombre,
ReferenciaTelefono = model.ReferenciaTelefono,
Actualidad = model.Actualidad
});
}
protected void btnAgregarExperiencia_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
listaExperiencia = (List <ExperienciaLaboral>)(HttpContext.Current.Session["listaExperiencia"]);
solicitante = (SolicitanteTrabajo)(HttpContext.Current.Session["solicitante"]);
ExperienciaLaboral experiencia = new ExperienciaLaboral();
experiencia.Puesto = tbPuesto.Text;
experiencia.Empresa = tbEmpresa.Text;
experiencia.FechaIngreso = Convert.ToDateTime(tbFechaInicio.Text);
experiencia.FechaTermino = Convert.ToDateTime(tbFechaFin.Text);
experiencia.DescripcionFunciones = txtFunciones.Value;
experiencia.SolicitanteTrabajo = solicitante;
listaExperiencia.Add(experiencia);
HttpContext.Current.Session.Add("listaExperiencia", listaExperiencia);
gvExperiencia.DataSource = listaExperiencia;
gvExperiencia.DataBind();
}
}
public List <ExperienciaLaboral> GetExperienciaLaboralSolicitante(int idSolicitante)
{
SqlConnection conexion = new SqlConnection(cadenaConexion);
SqlCommand cmdEx = new SqlCommand("select * from Experiencia_Laboral where id_solicitante = " + idSolicitante, conexion);
conexion.Open();
SqlDataReader drEx = cmdEx.ExecuteReader();
this.listaExperiencias = new List <ExperienciaLaboral>();
while (drEx.Read())
{
ExperienciaLaboral experiencia = new ExperienciaLaboral();
experiencia.Empresa = drEx["empresa"].ToString();
experiencia.Puesto = drEx["puesto"].ToString();
experiencia.FechaIngreso = DateTime.Parse(drEx["fecha_ingreso"].ToString());
experiencia.FechaTermino = DateTime.Parse(drEx["fecha_termino"].ToString());
listaExperiencias.Add(experiencia);
}
conexion.Close();
return(listaExperiencias);
}
public ActionResult <ExperienciaLaboral> Create(ExperienciaLaboral experienciaLaboral)
{
collectionServices.Create(experienciaLaboral);
return(CreatedAtRoute("GetExperienciaLaboral", new { id = experienciaLaboral.Id.ToString() }, experienciaLaboral));
}
public void Update(ExperienciaLaboral actualizarExperiencia)
{
_context.Update(actualizarExperiencia);
}
public void Delete(ExperienciaLaboral eliminarExperiencia)
{
_context.Remove(eliminarExperiencia);
}
public void Add(ExperienciaLaboral nuevaExperiencia)
{
_context.Add(nuevaExperiencia);
}
public Perfil GetPerfil([FromQuery] string alumnoId)
{
string connectionstring = _configuration.GetConnectionString("DefaultConnectionString");
SqlConnection connection = new SqlConnection(connectionstring);
connection.Open();
SqlCommand com = new SqlCommand("select perfil.id, " +
"perfil.nombre, " +
"perfil.apellido, " +
"perfil.pais_residencia as pais_residencia_id, pais.nombre as pais_nombre, " +
"perfil.provincia as provincia_id, provincia.nombre as provincia_nombre, " +
"perfil.zona as zona_id, zona.nombre as zona_nombre, " +
"perfil.ciudad as ciudad_id, ciudad.nombre as ciudad_nombre, " +
"perfil.localidad as localidad_id, localidad.nombre as localidad_nombre, " +
"perfil.fecha_nac, " +
"perfil.estado_civil, " +
"perfil.pais_nacionalidad as pais_nacionalidad_id, pais2.nombre as pais_nacionalidad_nombre, " +
"perfil.tipo_documento, " +
"perfil.documento, " +
"perfil.objetivo_laboral, " +
"perfil.intereses_personales, " +
"perfil.alumno, " +
"perfil.carrera as carrera_id, carrera.nombre as carrera_nombre, " +
"perfil.porcentaje_mat_apr, " +
"perfil.cantidad_mat_apr, " +
"perfil.promedio, " +
"perfil.anio_cursada " +
"from perfil perfil " +
"left join paises pais on perfil.pais_residencia = pais.id " +
"left join paises pais2 on perfil.pais_nacionalidad = pais2.id " +
"left join provincias provincia on perfil.provincia = provincia.id " +
"left join zonas zona on perfil.zona = zona.id " +
"left join ciudades ciudad on perfil.ciudad = ciudad.id " +
"left join localidades localidad on perfil.localidad = localidad.id " +
"left join carreras carrera on perfil.carrera = carrera.id " +
"where perfil.alumno = @alumno", connection);
com.Parameters.AddWithValue("@alumno", alumnoId);
SqlDataReader dr = com.ExecuteReader();
var perfil = new Perfil();
if (dr.HasRows)
{
while (dr.Read())
{
perfil.Id = dr["id"].ToString();
perfil.Nombre = dr["nombre"].ToString();
perfil.Apellido = dr["apellido"].ToString();
perfil.PaisResidencia = new IdValor[] { new IdValor {
Id = dr["pais_residencia_id"].ToString(), Valor = dr["pais_nombre"].ToString()
} };
perfil.ProvinciaResidencia = new IdValor[] { new IdValor {
Id = dr["provincia_id"].ToString(), Valor = dr["provincia_nombre"].ToString()
} };
perfil.Zona = new IdValor[] { new IdValor {
Id = dr["zona_id"].ToString(), Valor = dr["zona_nombre"].ToString()
} };
perfil.Ciudad = new IdValor[] { new IdValor {
Id = dr["ciudad_id"].ToString(), Valor = dr["ciudad_nombre"].ToString()
} };
perfil.Localidad = new IdValor[] { new IdValor {
Id = dr["localidad_id"].ToString(), Valor = dr["localidad_nombre"].ToString()
} };
perfil.FechaNacimientoDT = Convert.ToDateTime(dr["fecha_nac"].ToString());
perfil.EstadoCivil = dr["estado_civil"].ToString() != null ? new IdValor[] { new IdValor {
Id = GetEstadoCivilId(dr["estado_civil"].ToString()), Valor = dr["estado_civil"].ToString()
} } : null;
perfil.PaisNacionalidad = new IdValor[] { new IdValor {
Id = dr["pais_nacionalidad_id"].ToString(), Valor = dr["pais_nacionalidad_nombre"].ToString()
} };
perfil.TipoDocumento = dr["tipo_documento"].ToString();
perfil.Documento = dr["documento"].ToString();
perfil.ObjetivoLaboral = dr["objetivo_laboral"].ToString();
perfil.InteresesPersonales = dr["intereses_personales"].ToString();
perfil.Alumno = dr["alumno"].ToString();
perfil.Carrera = new IdValor[] { new IdValor {
Id = dr["carrera_id"].ToString(), Valor = dr["carrera_nombre"].ToString()
} };
perfil.PorcentajeMateriasAprobadas = (float)Convert.ToDouble(dr["porcentaje_mat_apr"]);
perfil.CantidadMateriasAprobadas = Convert.ToInt32(dr["cantidad_mat_apr"]);
perfil.Promedio = (float)Convert.ToDouble(dr["promedio"]);
perfil.AnioCursada = Convert.ToInt32(dr["anio_cursada"]);
}
}
else
{
return(null);
}
connection.Close();
connection.Open();
SqlCommand comRedesSociales = new SqlCommand("select id, red_social, tipo_red, mostrar_feed from redes_sociales where perfil = @perfil", connection);
comRedesSociales.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drRedesSociales = comRedesSociales.ExecuteReader();
if (drRedesSociales.HasRows)
{
perfil.RedesSociales = new RedesSociales();
while (drRedesSociales.Read())
{
switch (drRedesSociales["tipo_red"].ToString())
{
case "FB":
perfil.RedesSociales.usuarioFacebook = drRedesSociales["red_social"].ToString();
perfil.RedesSociales.mostrarFeedFacebook = (bool)drRedesSociales["mostrar_feed"];
break;
case "TW":
perfil.RedesSociales.usuarioTwitter = drRedesSociales["red_social"].ToString();
perfil.RedesSociales.mostrarFeedTwitter = (bool)drRedesSociales["mostrar_feed"];
break;
case "IG":
perfil.RedesSociales.usuarioInstagram = drRedesSociales["red_social"].ToString();
perfil.RedesSociales.mostrarFeedInstagram = (bool)drRedesSociales["mostrar_feed"];
break;
case "LI":
perfil.RedesSociales.usuarioLinkedIn = drRedesSociales["red_social"].ToString();
perfil.RedesSociales.mostrarFeedLinkedIn = (bool)drRedesSociales["mostrar_feed"];
break;
}
}
}
connection.Close();
connection.Open();
SqlCommand comExperienciasLaborales = new SqlCommand("select el.id, el.empresa, el.puesto as puesto_id, puesto.nombre as puesto_nombre, el.fecha_desde, el.fecha_hasta, el.actualmente_trabajando, cel.conocimiento as conocimiento_id, c.nombre as conocimiento_nombre, el.comentarios " +
"from experiencias_laborales el " +
"left join puestos puesto on el.puesto = puesto.id " +
"inner join conocimientos_x_experiencia_laboral cel on el.id = cel.experiencia_laboral " +
"left join conocimientos c on cel.conocimiento = c.id " +
"where perfil = @perfil", connection);
comExperienciasLaborales.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drExperienciasLaborales = comExperienciasLaborales.ExecuteReader();
if (drExperienciasLaborales.HasRows)
{
var experienciasLaborales = new List <ExperienciaLaboral>();
while (drExperienciasLaborales.Read())
{
var elIndex = experienciasLaborales.FindIndex(x => x.Id == drExperienciasLaborales["id"].ToString());
if (elIndex > -1)
{
//Lo convierto a List
List <Conocimiento> conocimientoListAux = new List <Conocimiento>(experienciasLaborales[elIndex].Conocimientos);
//Agrego el item
conocimientoListAux.Add(new Conocimiento {
Id = drExperienciasLaborales["conocimiento_id"].ToString(), Nombre = drExperienciasLaborales["conocimiento_nombre"].ToString()
});
//Lo vuelvo a Array
experienciasLaborales[elIndex].Conocimientos = conocimientoListAux.ToArray();
}
else
{
var experienciaLaboral = new ExperienciaLaboral();
experienciaLaboral.Id = drExperienciasLaborales["id"].ToString();
experienciaLaboral.Empresa = drExperienciasLaborales["empresa"].ToString();
experienciaLaboral.PuestoLaboral = new Puesto[] { new Puesto {
Id = drExperienciasLaborales["puesto_id"].ToString(), Nombre = drExperienciasLaborales["puesto_nombre"].ToString()
} };
experienciaLaboral.FechaDesdeDT = Convert.ToDateTime(drExperienciasLaborales["fecha_desde"].ToString());
experienciaLaboral.FechaHastaDT = Convert.ToDateTime(drExperienciasLaborales["fecha_hasta"].ToString());
experienciaLaboral.Conocimientos = new Conocimiento[] { new Conocimiento {
Id = drExperienciasLaborales["conocimiento_id"].ToString(), Nombre = drExperienciasLaborales["conocimiento_nombre"].ToString()
} };
experienciaLaboral.ActualmenteTrabajando = (bool)drExperienciasLaborales["actualmente_trabajando"];
experienciaLaboral.Descripcion = drExperienciasLaborales["comentarios"].ToString();
experienciasLaborales.Add(experienciaLaboral);
}
}
perfil.ExperienciaLaboral = experienciasLaborales.ToArray();
}
connection.Close();
connection.Open();
SqlCommand comED = new SqlCommand("select id, institucion, titulo, tipo_estudio, estado, fecha_desde, fecha_hasta, actualmente_estudiando, comentarios " +
"from experiencias_educativas " +
"where perfil = @perfil", connection);
comED.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drED = comED.ExecuteReader();
if (drED.HasRows)
{
var experienciasEducativas = new List <ExperienciaEducativa>();
while (drED.Read())
{
var experienciaEducativa = new ExperienciaEducativa();
experienciaEducativa.Id = drED["id"].ToString();
experienciaEducativa.Institucion = drED["institucion"].ToString();
experienciaEducativa.Titulo = drED["titulo"].ToString();
experienciaEducativa.TipoEstudio = new IdValor[] { new IdValor {
Id = GetTipoEstudio(drED["tipo_estudio"].ToString()), Valor = drED["tipo_estudio"].ToString()
} };
experienciaEducativa.Estado = new IdValor[] { new IdValor {
Id = GetEstado(drED["estado"].ToString()), Valor = drED["estado"].ToString()
} };
experienciaEducativa.FechaDesdeDT = Convert.ToDateTime(drED["fecha_desde"].ToString());
experienciaEducativa.FechaHastaDT = Convert.ToDateTime(drED["fecha_hasta"].ToString());
experienciaEducativa.ActualmenteEstudiando = Convert.ToBoolean(drED["actualmente_estudiando"]);
experienciaEducativa.Comentarios = drED["comentarios"].ToString();
experienciasEducativas.Add(experienciaEducativa);
}
perfil.ExperienciaEducativa = experienciasEducativas.ToArray();
}
connection.Close();
connection.Open();
SqlCommand comIdioma = new SqlCommand("select ixp.id, ixp.idioma as idioma_id, i.nombre_idioma, ixp.nivel_oral, ixp.nivel_escrito, ixp.comentarios " +
"from idiomas_x_perfil ixp inner join idiomas i on ixp.idioma = i.id " +
"where perfil = @perfil", connection);
comIdioma.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drIdioma = comIdioma.ExecuteReader();
if (drIdioma.HasRows)
{
var idiomas = new List <Idioma>();
while (drIdioma.Read())
{
var idioma = new Idioma();
idioma.Id = drIdioma["id"].ToString();
idioma.NombreIdioma = new IdValor[] { new IdValor {
Id = drIdioma["idioma_id"].ToString(), Valor = drIdioma["nombre_idioma"].ToString()
} };
idioma.NivelOral = new IdValor[] { new IdValor {
Id = GetNivel(drIdioma["nivel_oral"].ToString()), Valor = drIdioma["nivel_oral"].ToString()
} };
idioma.NivelEscrito = new IdValor[] { new IdValor {
Id = GetNivel(drIdioma["nivel_escrito"].ToString()), Valor = drIdioma["nivel_escrito"].ToString()
} };
idioma.Comentarios = drIdioma["comentarios"].ToString();
idiomas.Add(idioma);
}
perfil.Idioma = idiomas.ToArray();
}
connection.Close();
connection.Open();
SqlCommand comCXP = new SqlCommand("select cxp.id, cxp.conocimiento, c.nombre " +
"from conocimientos_x_perfil cxp inner join conocimientos c on cxp.conocimiento = c.id " +
"where perfil = @perfil", connection);
comCXP.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drCXP = comCXP.ExecuteReader();
if (drCXP.HasRows)
{
var conocimientos = new List <IdValor>();
while (drCXP.Read())
{
var conocimiento = new IdValor();
conocimiento.Id = drCXP["conocimiento"].ToString();
conocimiento.Valor = drCXP["nombre"].ToString();
conocimientos.Add(conocimiento);
}
perfil.OtrosConocimientos = conocimientos.ToArray();
}
connection.Close();
connection.Open();
SqlCommand comEmail = new SqlCommand("select id, correo from correos_electronicos " +
"where perfil = @perfil", connection);
comEmail.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drEmail = comEmail.ExecuteReader();
if (drEmail.HasRows)
{
var emails = new List <IdValor>();
while (drEmail.Read())
{
var email = new IdValor();
email.Id = drEmail["id"].ToString();
email.Valor = drEmail["correo"].ToString();
emails.Add(email);
}
perfil.Emails = emails.ToArray();
}
connection.Close();
connection.Open();
SqlCommand comTelefono = new SqlCommand("select id, numero_telefono from telefonos " +
"where perfil = @perfil", connection);
comTelefono.Parameters.AddWithValue("@perfil", perfil.Id);
SqlDataReader drTelefono = comTelefono.ExecuteReader();
if (drTelefono.HasRows)
{
var telefonos = new List <IdValor>();
while (drTelefono.Read())
{
var telefono = new IdValor();
telefono.Id = drTelefono["id"].ToString();
telefono.Valor = drTelefono["numero_telefono"].ToString();
telefonos.Add(telefono);
}
perfil.Telefonos = telefonos.ToArray();
}
connection.Close();
return(perfil);
}
/// <summary>
/// Agrega nueva información de la experiencia laboral de un usuario registrado
/// </summary>
/// <param name="experienciaLaboral"></param>
/// <returns></returns>
public bool Agregar(ExperienciaLaboral experienciaLaboral)
{
BD.ExperienciaLaboral.Add(experienciaLaboral);
return(BD.SaveChanges() > 0);
}
public void Remove(ExperienciaLaboral experienciaLaboralIn) => experienciaLaborales.DeleteOne(experiencia => experiencia.Id == experienciaLaboralIn.Id);
public void Update(string id, ExperienciaLaboral experienciaLaboralIn) => experienciaLaborales.ReplaceOne(experiencia => experiencia.Id == id, experienciaLaboralIn);
public ExperienciaLaboral Create(ExperienciaLaboral experienciaLaboral)
{
experienciaLaborales.InsertOne(experienciaLaboral);
return(experienciaLaboral);
}
public void Actualizar(ExperienciaLaboral experienciaLaboral)
{
DB.Entry(experienciaLaboral).State = EntityState.Modified;
DB.SaveChanges();
}
public IActionResult Create(ExperienciaLaboral experiencia, int idCandidato)
{
sv.Nuevo(experiencia, idCandidato);
return(RedirectToAction("Index", "Home", new { id = idCandidato }));
}
public bool Actualizar(ExperienciaLaboral experiencia)
{
var dato = repositorio.Actualizar(experiencia);
return(dato);
}
