protected void Button1_Click(object sender, EventArgs e)
{
if ((Boolean)Session["bandera"] == false) //inserta
{
Usuario usuario = (Usuario)Session["usuario"];
Domicilio domicilio = crearDomicilio();
Candidato candidato = crearCandidato();
Experiencia experiencia = crearExperiencia();
Curriculum curriculum = crearCurriculum();
List <Conocimientos> conocimientosXCurriculum = crearConocimientos();
List <MotorBD> motoresXCurriculum = (List <MotorBD>)Session["listaBD"];
List <Software> softwarXCurriculm = (List <Software>)Session["listaSW"];
List <Lenguaje> lenguajesXCurriculum = (List <Lenguaje>)Session["listaLenguaje"];
List <SistemaOperativo> SOPXCurriculum = (List <SistemaOperativo>)Session["listaSOP"];
List <Idioma> idiomas = (List <Idioma>)Session["listaIdioma"];
GestorCurriculum.guardarCV(usuario, candidato, domicilio, experiencia, curriculum, conocimientosXCurriculum, motoresXCurriculum, softwarXCurriculm, lenguajesXCurriculum, SOPXCurriculum, idiomas);
Response.Write("<script>alert('El curriculum se a guardo con exito');document.location.href='./Inicio.aspx';</script>");
}
else //modifica
{
Usuario usuario = (Usuario)Session["usuario"];
Domicilio domicilio = crearDomicilio();
Candidato candidato = crearCandidato();
Experiencia experiencia = crearExperiencia();
Curriculum curriculum = crearCurriculum();
List <Conocimientos> conocimientosXCurriculum = crearConocimientos();
List <MotorBD> motoresXCurriculum = (List <MotorBD>)Session["listaBD"];
List <Software> softwarXCurriculm = (List <Software>)Session["listaSW"];
List <Lenguaje> lenguajesXCurriculum = (List <Lenguaje>)Session["listaLenguaje"];
List <SistemaOperativo> SOPXCurriculum = (List <SistemaOperativo>)Session["listaSOP"];
List <Idioma> idiomas = (List <Idioma>)Session["listaIdioma"];
GestorCurriculum.modificarCV(curriculum, usuario, candidato, domicilio, experiencia, curriculum, conocimientosXCurriculum, motoresXCurriculum, softwarXCurriculm, lenguajesXCurriculum, SOPXCurriculum, idiomas);
Response.Write("<script>alert('El curriculum se a guardo con exito');document.location.href='./Inicio.aspx';</script>");
}
}
public async Task <IActionResult> Edit(int id, [Bind("ExperienciaId,Nome,Descricao,Data_Inicio,Data_Fim")] Experiencia experiencia)
{
if (id != experiencia.ExperienciaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(experiencia);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExperienciaExists(experiencia.ExperienciaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(experiencia));
}
public async Task <bool> DeleteExperiencia(Experiencia experiencia)
{
string sql = "DELETE FROM dbo.Experiencia WHERE IdExperiencia = '" + experiencia.IdExperiencia + "'";
var result = await _dataAccess.SaveData <Experiencia>(sql, experiencia);
return(result == 1);
}
public Experiencia crearExperiencia()
{
Experiencia experiencia = new Experiencia();
String nombreEmpresa = txtNombreEmpresa.Text.ToString();
experiencia.nombreEmpresa = nombreEmpresa;
int idActividad = Convert.ToInt32(cbActivdad.SelectedValue);
experiencia.idActividad = idActividad;
int idJerarquia = Convert.ToInt32(cbJerarquia.SelectedValue);
experiencia.idJerarquia = idJerarquia;
int idDuracion = Convert.ToInt32(cbTiempo.SelectedValue);
experiencia.idDuracion = idDuracion;
int idArea = Convert.ToInt32(cbArea.SelectedValue);
experiencia.idArea = idArea;
if (Session["usuario"] != null)
{
if (recuperarExperiencia((Usuario)Session["usuario"]) != null)
{
experiencia.idExperiencia = recuperarExperiencia((Usuario)Session["usuario"]).idExperiencia;
experiencia.numeroDoc = recuperarExperiencia((Usuario)Session["usuario"]).numeroDoc;
experiencia.tipoDoc = recuperarExperiencia((Usuario)Session["usuario"]).tipoDoc;
}
}
return(experiencia);
}
public JsonResult Agregar(Experiencia modelo)
{
mRespuestaAjax = new RespuestaServidor();
mRespuestaAjax.mensaje = "El campo Descripción es requerido";
if (ModelState.IsValid)
{
int result = DateTime.Compare(modelo.Desde, modelo.Hasta);
if (result > 0)
{
mRespuestaAjax.SetResponse(false, "Campo 'Hasta' no puede ser <b>MENOR</b> que 'Desde'");
}
else
{
bool guardado = modelo.GuardarExperiencia();
if (guardado)
{
mRespuestaAjax.SetResponse(true);
mRespuestaAjax.href = Url.Content("~/admin/experiencia?tipo=" + modelo.Tipo);
}
else
{
mRespuestaAjax.SetResponse(false, "Error al guardar los datos");
}
}
}
return(Json(mRespuestaAjax));
}
public async Task <IActionResult> Edit(int id, [Bind("ExperienciaId,Ano,Empresa,Cargo")] Experiencia experiencia)
{
if (id != experiencia.ExperienciaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
bd.Update(experiencia);
await bd.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExperienciaExists(experiencia.ExperienciaId))
{
return(View("EliminarInserir", experiencia));
}
else
{
ModelState.AddModelError("", "Ocorreu um erro. Não foi possível guardar o produto. Tente novamente e se o problema persistir contacte a assistência.");
return(View(experiencia));
}
}
//return RedirectToAction(nameof(Index));
ViewBag.Mensagem = "Experiência alterada com sucesso";
return(View("Sucesso"));
}
return(View(experiencia));
}
public static void modificarExperiencia(Experiencia exp)
{
SqlConnection cn = null;
try
{
cn = new SqlConnection(cadenaConexion);
cn.Open();
String sql = "UPDATE EXPERIENCIA ";
sql = sql + "SET nombreEmpresa='" + exp.nombreEmpresa + "', idActividad=" + exp.idActividad + ", idJerarquia=" + exp.idJerarquia + ", idDuracionExperiencia=" + exp.idDuracion + ",idArea=" + exp.idArea;
sql = sql + " WHERE TipoDoc=" + exp.tipoDoc + " AND nroDoc=" + exp.numeroDoc;
SqlCommand cmd = new SqlCommand(sql, cn);
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
if (cn != null && ConnectionState.Open == cn.State)
{
cn.Close();
}
}
}
public ActionResult Edit(Experiencia objeto)
{
try
{
Experiencia.TransactionInstance.Save(objeto);
return RedirectToAction("Index", new { displayMessage = MENSAGEM_ALTERACAO });
}
catch (ApplicationException ex)
{
string[] campos = ex.Message.Split(',');
ModelState.AddModelError(string.Empty, MENSAGEM_CAMPOS_OBRIGATORIOS);
foreach (string campo in campos)
{
ModelState[campo].Errors.Add(ex);
}
return View(objeto);
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return View(objeto);
}
}
public static void insertarExperiencia(Experiencia exp, Usuario usuario, Candidato candidato)
{
SqlConnection cn = null;
try
{
cn = new SqlConnection(cadenaConexion);
cn.Open();
String sql = " INSERT INTO Experiencia (nombreEmpresa, idActividad, idJerarquia, idDuracionExperiencia, nroDoc, tipoDoc, idArea ) VALUES('" + exp.nombreEmpresa + "'," + exp.idActividad + "," + exp.idJerarquia + "," + exp.idDuracion + "," + candidato.numeroDoc + "," + candidato.tipoDoc + "," + exp.idArea + ")";
SqlCommand cmd = new SqlCommand(sql, cn);
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
finally
{
if (cn != null && ConnectionState.Open == cn.State)
{
cn.Close();
}
}
}
public bool ExcluirExperiencia(Experiencia exp)
{
var curriculoDados = new PerfilCurricular.Models.CurriculoDAL();
var retExcluir = curriculoDados.ExcluirExperiencia(exp);
return(retExcluir.Success);
}
public bool addExperiencia(ExperienciaDTO exper)
{
using (var context = getContext())
{
try
{
Experiencia nuevo = new Experiencia();
nuevo.IdExperiencia = exper.IdMiembro;
nuevo.IdTipoExperiencia = exper.IdTipoExperiencia;
nuevo.IdMiembro = exper.IdMiembro;
nuevo.Titulo = exper.Titulo;
nuevo.Texto = exper.Texto;
nuevo.Orden = exper.Orden;
nuevo.Active = true;
context.Experiencia.Add(nuevo);
context.SaveChanges();
return(true);
}
catch (Exception e)
{
throw e;
}
}
}
public JsonResult Edit(ExperienciaFormViewModel viewModel)
{
if (!viewModel.Id.HasValue)
{
return(Json(new JsonResponse(false, "Id não encontrado para edição.")));
}
Experiencia experiencia = new Experiencia();
experiencia.Id = viewModel.Id.Value;
experiencia.Profissao = viewModel.Profissao;
experiencia.Empresa = viewModel.Empresa;
experiencia.DataFim = viewModel.DataFim;
experiencia.DataInicio = viewModel.DataInicio;
Cidade cidadeExperiencia = _cidadeService.FindById(viewModel.IdCidade);
if (cidadeExperiencia == null)
{
return(Json(new JsonResponse(false, "Cidade não encontrada.")));
}
cidadeExperiencia.Estado = _estadoService.FindById(viewModel.IdEstado);
experiencia.Cidade = cidadeExperiencia;
experiencia.Detalhes = viewModel.Detalhes;
var editaExperiencia = _experienciaService.Edit(experiencia);
if (!editaExperiencia)
{
return(Json(new JsonResponse(false, "Impossível editar esta experiência. Por favor, entre em contato com a equipe de desenvolvimento.")));
}
return(Json(new JsonResponse(true, "Experiência editada com sucesso!")));
}
public Experiencia recuperarExperiencia(Usuario usuario)
{
Experiencia experiencia = null;
experiencia = GestorCurriculum.recuperarExperiencia(usuario);
return(experiencia);
}
public async Task <bool> UpdateExperiencia(Experiencia experiencia)
{
string sql = "UPDATE dbo.Experiencia SET IdCurriculum = '" + experiencia.IdCurriculum + "', Puesto = '" + experiencia.Puesto + "', FechaInicio = '" + experiencia.FechaInicio + "', FechaFin = '" + experiencia.FechaFin + "', Empresa = '" + experiencia.Empresa + "', DescripcionPuesto = '" + experiencia.DescripcionPuesto + "' " +
"WHERE IdExperiencia = '" + experiencia.IdExperiencia + "'";
var result = await _dataAccess.SaveData <Experiencia>(sql, experiencia);
return(result == 1);
}
public string DeletaExperiencia(int idExperiencia)
{
Experiencia ExperienciaBd = this.context.Experiencia.FirstOrDefault(t => t.Id == idExperiencia);
this.context.Experiencia.Remove(ExperienciaBd);
this.context.SaveChanges();
return("Experiencia deletada com sucesso.");
}
public bool AgregarExperiencia(Experiencia Experiencia)
{
using (SQLContexto contexto = new SQLContexto())
{
ExperienciaRepo experienciaRepo = new ExperienciaRepo(contexto);
return(experienciaRepo.Insertar(Experiencia));
}
}
public bool ModificarExperiencia(Experiencia Experiencia)
{
using (SQLContexto contexto = new SQLContexto())
{
ExperienciaRepo experienciaRepo = new ExperienciaRepo(contexto);
return(experienciaRepo.Actualizar(Experiencia));
}
}
public ActionResult DeleteConfirmed(int id)
{
Experiencia experiencia = db.Experiencias.Find(id);
db.Experiencias.Remove(experiencia);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult IncluirExperiencia(Experiencia experiencia)
{
if (ModelState.IsValid)
{
dao.IncluirExperiencia(experiencia);
return(RedirectToAction("Detalhes", new { id = experiencia.CandidatoId }));
}
return(BadRequest());
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Experiencia experiencia = await db.Experiencia.FindAsync(id);
db.Experiencia.Remove(experiencia);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private void CargarTextBoxesExperiencia(Experiencia experiencia)
{
txtExpCodigo.Text = experiencia.Codigo.ToString();
txtExpEmpresa.Text = experiencia.Empresa;
txtExpPuesto.Text = experiencia.Puesto;
txtExpFechaDesde.Text = experiencia.FechaDesde.ToString();
txtExpFechaHasta.Text = experiencia.FechaHasta.ToString();
txtExpDescripcion.Text = experiencia.Descripcion;
}
public string AlterarPessoa([FromBody] Pessoa Pessoa)
{
if (Pessoa != null)
{
using (ANGULARCRUDContext Con = new ANGULARCRUDContext())
{
Pessoa Obj = Con.Pessoa.Where(x => x.IdPessoa == Pessoa.IdPessoa).FirstOrDefault();
if (Obj == null)
{
return("Está Pessoa não foi encontrada em nosso banco de dados, por favor contate o suporte.");
}
var listaExperencia = (from i in Con.Experiencia where i.IdPessoa == Pessoa.IdPessoa select i).ToList();
Con.Experiencia.RemoveRange(listaExperencia);
Obj.Email = Pessoa.Email;
Obj.Telefone = Pessoa.Telefone;
Obj.Nome = Pessoa.Nome;
Obj.Idade = Pessoa.Idade;
Obj.Skype = Pessoa.Skype;
Obj.Cidade = Pessoa.Cidade;
Obj.Portfolio = Pessoa.Portfolio;
Obj.NomeBanco = Pessoa.NomeBanco;
Obj.Cpf = Pessoa.Cpf;
Obj.NomePessoaBanco = Pessoa.NomePessoaBanco;
Obj.TipoConta = Pessoa.TipoConta;
Obj.Agencia = Pessoa.Agencia;
Obj.NrConta = Pessoa.NrConta;
Obj.Opconta = Pessoa.Opconta;
Obj.Disponibilidade = Pessoa.Disponibilidade;
Obj.Horario = Pessoa.Horario;
Con.SaveChanges();
if (Pessoa.Experiencia != null)
{
foreach (var exp in Pessoa.Experiencia)
{
Experiencia objExp = new Experiencia();
objExp.IdPessoa = Obj.IdPessoa;
objExp.Nivel = exp.Nivel;
objExp.Nome = exp.Nome;
Obj.Experiencia.Add(objExp);
}
Con.SaveChanges();
}
return("Sucesso");
}
}
else
{
return("Erro");
}
}
public Experiencia Adicionar(Experiencia experiencia)
{
//TODO: Executa as validacoes
if (!experiencia.IsValid())
{
return(experiencia);
}
return(_experienciaRepositorio.Adicionar(experiencia));
}
public ActionResult Edit([Bind(Include = "ExperienciaID,InfoExperiencia")] Experiencia experiencia)
{
if (ModelState.IsValid)
{
db.Entry(experiencia).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(experiencia));
}
public string AlteraExperiencia(Experiencia Experiencia)
{
Experiencia ExperienciaBd = this.context.Experiencia.FirstOrDefault(t => t.Id == Experiencia.Id);
ExperienciaBd.Nivel = Experiencia.Nivel;
ExperienciaBd.Valor = Experiencia.Valor;
this.context.SaveChanges();
return("Experiencia atualizada com sucesso");
}
public ActionResult Create([Bind(Include = "ExperienciaID,InfoExperiencia")] Experiencia experiencia)
{
if (ModelState.IsValid)
{
db.Experiencias.Add(experiencia);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(experiencia));
}
public IActionResult ExcluirExperiencia(int id)
{
Experiencia experiencia = dao.BuscarExperiencia(id);
if (experiencia != null)
{
dao.ExcluirExperiencia(experiencia);
return(RedirectToAction("Detalhes", new { id = experiencia.CandidatoId }));
}
return(NotFound());
}
public async Task <IActionResult> Create([Bind("ExperienciaId,Empresa,Duracao")] Experiencia experiencia)
{
if (ModelState.IsValid)
{
_context.Add(experiencia);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(experiencia));
}
public ActionResult Create([Bind(Include = "id,titulo,name,detalles")] Experiencia experiencia)
{
if (ModelState.IsValid)
{
db.Experiencias.Add(experiencia);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(experiencia));
}
public async Task <IActionResult> Create([Bind("ExperienciaId,Nome,Descricao,Data_Inicio,Data_Fim")] Experiencia experiencia)
{
if (ModelState.IsValid)
{
_context.Add(experiencia);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(experiencia));
}
public JsonResult Delete(int idExperiencia)
{
Experiencia experiencia = _experienciaService.FindById(idExperiencia);
var deletaExperiencia = _experienciaService.Delete(experiencia);
if (!deletaExperiencia)
{
return(Json(new JsonResponse(false, "Impossivel remover experiência: Id não encontrado.")));
}
return(Json(new JsonResponse(true, "Experiência deletada com sucesso!")));
}
public ActionResult Remove(Experiencia objeto)
{
Experiencia.TransactionInstance.Remove(objeto);
return RedirectToAction("Index", new { displayMessage = MENSAGEM_EXCLUSAO });
}
