// GET: Requerimiento/Details/5
public async Task <ActionResult> Details(string nombreProy, int modID, string nombreReq)
{
using (Gr02Proy3Entities db = new Gr02Proy3Entities())
{
//obtiene el nombre del modulo por medio de sus llaves primarias
ViewBag.nombreModulo = db.Modulo.Find(nombreProy, modID).Nombre;
//busca el requerimiento por medio de sus llaves primarias
Requerimiento requerimiento = await db.Requerimiento.FindAsync(nombreProy, modID, nombreReq);
if (requerimiento == null)
{
return(HttpNotFound());
}
//busca el responsable del requerimiento y en otro caso coloca que no se a asignado
if (requerimiento.cedulaResponsable_FK != null)
{
ViewBag.ApellidoEmpleado = db.EmpleadoDesarrollador.Find(requerimiento.cedulaResponsable_FK).apellido1ED;
}
else
{
ViewBag.ApellidoEmpleado = "No asignado";
}
return(View(requerimiento));
}
}
public async Task <IActionResult> PutRequerimiento(int id, Requerimiento requerimiento)
{
if (id != requerimiento.IdRequerimiento)
{
return(BadRequest());
}
_context.Entry(requerimiento).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequerimientoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult DeleteConfirmed(int id)
{
Requerimiento requerimiento = db.Requerimientos.Find(id);
db.Requerimientos.Remove(requerimiento);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//
// GET: /Requerimientos/Edit/5
public ActionResult Edit(int id)
{
Requerimiento requerimiento = db.Requerimientos.Find(id);
ViewBag.IdLiderProyecto = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno", requerimiento.IdLiderProyecto);
ViewBag.IdIdS = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno", requerimiento.IdIdS);
return(View(requerimiento));
}
private void Requerimiento_List_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (e.SelectedItem != null)
{
Requerimiento modelo = (Requerimiento)e.SelectedItem;
Navigation.PushAsync(new PostulantesPregPage(modelo, postulante));
}
}
public ActionResult DeleteConfirmed(string nombreProyecto, int modID, string nombreReq)
{
Requerimiento requerimiento = db.Requerimiento.Find(nombreProyecto, modID, nombreReq);
db.Requerimiento.Remove(requerimiento);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//------------------------------------METHODS AND FUNCTIONS CREATED BY THE TEAM-------------------------------------
//<summary> : It is used to remove a requirement from the database.
//<param> : int id : this parameter is an identifier for the requirement that will be removed from the database
// int? projectId : is the id of the project related with the requirement.
//<return> : Redirect to Index,where the requirements appears
public ActionResult removeRequirement(int id, int?projectId)
{
Requerimiento requerimiento = db.Requerimientoes.Find(id, projectId);
db.Requerimientoes.Remove(requerimiento);
db.SaveChanges( );
return(RedirectToAction("Index", new { projectId = projectId }));
}
public AddPreguntaRequer(Requerimiento requerimiento)
{
InitializeComponent();
ListaPreguntas();
idReq = requerimiento.idRequerimiento;
modelo = requerimiento;
}
public ActionResult CrearRequerimiento(Requerimiento requerimiento)
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
if (ModelState.IsValid)
{
var estado = db.EstadoRequerimiento.Where(p => p.nombre == "Pendiente Aprobación").SingleOrDefault();
var estadoDetalle = db.EstadoRequerimientoDetalle.Where(p => p.nombre == "Sin Aprobación").SingleOrDefault();
DateTime timeUtc = DateTime.UtcNow;
TimeZoneInfo cstZone = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");
DateTime cstTime = TimeZoneInfo.ConvertTimeFromUtc(timeUtc, cstZone);
requerimiento.fechaCreacion = cstTime;
requerimiento.usuarioCreacion = User.Identity.Name;
requerimiento.fechaModificacion = cstTime;
requerimiento.EstadoRequerimiento = estado;
db.Requerimientos.Add(requerimiento);
//db.SaveChanges();
foreach (var item in requerimiento.Detalles)
{
item.estadoRequerimientoDetalleId = estadoDetalle.estadoRequerimientoDetalleId;
db.RequerimientoDetalles.Add(item);
var requerimientoDetalleEstadoRequerimientoDetalle = new RequerimientoDetalleEstadoRequerimientoDetalle();
requerimientoDetalleEstadoRequerimientoDetalle.RequerimientoDetalle = item;
requerimientoDetalleEstadoRequerimientoDetalle.estadoRequerimientoDetalleId = estadoDetalle.estadoRequerimientoDetalleId;
requerimientoDetalleEstadoRequerimientoDetalle.usuarioCreacion = User.Identity.Name;
requerimientoDetalleEstadoRequerimientoDetalle.fechaCreacion = cstTime;
db.RequerimientoDetalleEstadoRequerimientoDetalle.Add(requerimientoDetalleEstadoRequerimientoDetalle);
}
var requerimientoEstado = new RequerimientoEstadoRequerimiento();
requerimientoEstado.Requerimiento = requerimiento;
requerimientoEstado.estadoRequerimientoId = estado.estadoRequerimientoId;
requerimientoEstado.usuarioCreacion = User.Identity.Name;
requerimientoEstado.fechaCreacion = cstTime;
db.RequerimientoEstadoRequerimiento.Add(requerimientoEstado);
db.SaveChanges();
//return View("Index");
//return RedirectToAction("Index/" + requerimiento.tipoCompraId);
return(RedirectToAction("Index"));
}
return(View(requerimiento));
}
public ActionResult Edit(int idProyecto, int idRequerimiento, string nombre, string complejidad, string descripcion, string estado, int?duracionEstimada,
int?duracionReal, DateTime fechai, DateTime?fechaf, string resultado, string estadoR, string detalleResultado, string idTesterViejo, string idTesterNuevo)
{
Requerimiento requerimiento = db.Requerimiento.Find(idRequerimiento, idProyecto);
requerimiento.nombre = nombre;
requerimiento.complejidad = complejidad;
requerimiento.descripcion = descripcion;
requerimiento.fechaDeFinalizacion = fechaf;
requerimiento.idProyectoFK = idProyecto;
requerimiento.detallesResultado = detalleResultado;
if (duracionReal.HasValue)
{
requerimiento.tiempoReal = duracionReal;
}
if (estado != "")
{
requerimiento.estado = estado;
}
if (duracionEstimada != null)
{
requerimiento.tiempoEstimado = (int)duracionEstimada;
}
if (fechai != null)
{
requerimiento.fechaDeInicio = (DateTime)fechai;
}
if (idTesterNuevo != "")
{
requerimiento.cedulaTesterFK = idTesterNuevo;
}
else
{
requerimiento.cedulaTesterFK = null;
}
if (resultado != "")
{
if (resultado == "true")
{
requerimiento.resultado = true;
}
requerimiento.resultado = false;
}
if (estadoR != "")
{
requerimiento.estadoResultado = estadoR;
}
db.Entry(requerimiento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { idProyecto = idProyecto, idRequerimiento = requerimiento.idReqPK }));
}
public ActionResult Crud(int id = 0)
{
mLlenarLsitas();
if (id > 0)
{
requerimiento = (new Requerimiento()).ObtenerRequerimiento(id);
}
return(View(requerimiento));
}
public OrdenCompraViewModel(List <FormaPago> formasPago, List <Proveedor> proveedores, Requerimiento requerimiento, List <OrdenCompra> ordenes, List <Moneda> monedas, TipoCompra tipoCompra)
{
FormasPago = formasPago;
Proveedores = proveedores;
Requerimiento = requerimiento;
Ordenes = ordenes;
Monedas = monedas;
TipoCompra = tipoCompra;
}
public ActionResult DeleteConfirmedReq(int id)
{
Requerimiento requerimientos = db.Requerimientos.Find(id);
db.Requerimientos.Remove(requerimientos);
db.SaveChanges();
return(RedirectToAction("Perfil", "Admin", new { id = requerimientos.perfil_id }));
/* return RedirectToAction("Index"); */
}
public async Task <ActionResult> DeleteConfirmed(int id, int projectId)
{
Requerimiento requerimiento = await db.Requerimientoes.FindAsync(id, projectId);
db.Requerimientoes.Remove(requerimiento);
await db.SaveChangesAsync( );
return(RedirectToAction("Index", new { projectId = projectId }));
}
protected void cpCargaListaMaterialesR_Callback(object sender, CallbackEventArgsBase e)
{
using (var wu = new UnidadDeTrabajo())
{
Requerimiento ReqRep = wu.Requerimiento.ObtenerPorId(int.Parse(e.Parameter.ToString()));
txtIdReq.Text = string.Format("{0:00000000}", ReqRep.Id);
lbxListaMateriales.DataSource = wu.RequerimientoDetalle.ObtenerMaterialesRequerimiento(ReqRep.Id);
lbxListaMateriales.DataBind();
}
}
// Efecto: Método que recibe la confirmación del usuario para eliminar un requerimiento de la base de datos. Esto es, si ya se verificó que el usuario
// posee los permisos para eliminarlos y además, está cancelado ya.
// Requiere: int idRequerimiento -> Es parte de la llave primaria utilizada para encontrar el requerimiento que se desea eliminar.
// int idProyecto -> La otra parte de dicha llave primaria, con estos dos elementos se encuentra el elemento que el usuario desea eliminar y se elimina.
// Modifica: Se modifica la BD, elminando el requerimiento que se encuentra por medio de los atributos pasados como parametros.
public ActionResult Eliminar(int idRequerimiento, int idProyecto)
{
if (Request.IsAuthenticated)
{
Requerimiento requerimiento = db.Requerimiento.Find(idRequerimiento, idProyecto);
db.Requerimiento.Remove(requerimiento);
db.SaveChanges();
}
return(RedirectToAction("Index", new { idProyecto = idProyecto, idRequerimiento = 0 }));
}
public ActionResult DetalleHoras(int id)
{
requerimiento = requerimiento.ObtenerRequerimiento(id);
List <Horas> hora = new List <Horas>();
hora = horas.ObtenerHorasRequerimiento(id);
ViewBag.Requerimiento = requerimiento;
ViewBag.horas = hora;
return(View());
}
public ActionResult Edit([Bind(Include = "Id,Fecha_req,Fecha_limit_req,Fecha_fin_real")] Requerimiento requerimiento)
{
if (ModelState.IsValid)
{
db.Entry(requerimiento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(requerimiento));
}
//
// GET: /Requerimientos/Create
public ActionResult Create()
{
ViewBag.IdLiderProyecto = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno");
ViewBag.IdIdS = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno");
Requerimiento requerimiento = new Requerimiento();
requerimiento.FechaPriorizacion = DateTime.Now;
return(View(requerimiento));
}
public async Task <Requerimiento> save(Requerimiento requerimiento)
{
requerimiento.Dml = "I";
requerimiento.UpDateTime = new DateTime();
requerimiento.CreateTime = new DateTime();
dbContext.Requerimientos.Add(requerimiento);
await dbContext.SaveChangesAsync();
return(requerimiento);
}
public PostulantesRequerPage(Requerimiento modelo)
{
InitializeComponent();
requerimiento = modelo;
url = Servicio.IP + "postulante/listPostulanteByIdReq/" + modelo.idRequerimiento;
IdRequerimiento = modelo.idRequerimiento;
ListaPostulantesReq();
ListaPreguntasReq();
}
/******************************************METHOD'S*******************************/
public async Task <Requerimiento> deleteById(int Id)
{
Requerimiento requerimiento = findById(Id).Result;
requerimiento.Dml = "D";
dbContext.Requerimientos.Update(requerimiento);
await dbContext.SaveChangesAsync();
return(requerimiento);
}
public ActionResult Edit([Bind(Include = "id_requerimiento,id_proyecto,descripcion")] Requerimiento requerimiento)
{
if (ModelState.IsValid)
{
db.Entry(requerimiento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.id_proyecto = new SelectList(db.Proyecto, "id_proyecto", "nombre", requerimiento.id_proyecto);
return(View(requerimiento));
}
public ActionResult Create([Bind(Include = "Id,Fecha_req,Fecha_limit_req,Fecha_fin_real")] Requerimiento requerimiento)
{
if (ModelState.IsValid)
{
db.Requerimiento.Add(requerimiento);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(requerimiento));
}
public Estadoreq GetEstadoRequerimiento(int idRequerimiento)
{
Estadoreq estadoreq = null;
Requerimiento requerimiento = RequerimientoDao.Get(x => x.Idrequerimiento == idRequerimiento);
if (requerimiento != null)
{
estadoreq = EstadoreqDao.Get(x => x.Idestadoreq == requerimiento.Idestadoreq);
}
return(estadoreq);
}
public IHttpActionResult listRequerimientoByIdReq(int idRequerimiento)
{
Requerimiento objRequerimiento = new Requerimiento();
//GettingListOfListaDePregDet : Este Objeto almacenará la ListaDePregDet
objRequerimiento = GetRequerimientoBO.listRequerimientoByIdReq(idRequerimiento);
var resultado = objRequerimiento;
return(Json(resultado));
}
protected void dgRequerimientoDetalle_BatchUpdate(object sender, DevExpress.Web.Data.ASPxDataBatchUpdateEventArgs e)
{
try
{
NumeroRequerimiento = Request.QueryString["Id"];
using (var db = new UnidadDeTrabajo())
{
if (NumeroRequerimiento == "Nuevo")
{
Requerimiento req = new Requerimiento
{
Fecha = DateTime.Now,
FechaCreacion = DateTime.Now,
IdUsuario = Session["IdUserActive"] != null?int.Parse(Session["IdUserActive"].ToString()) : 1,
TipoRequerimiento = "",
DocumentoReferencia = "",
IdEstado = 26,
};
db.Requerimiento.Insertar(req);
db.Grabar();
foreach (var item in e.InsertValues)
{
db.RequerimientoDetalle.InsertarValoresRequerimientoDetalle(item.NewValues, req.Id, decimal.Parse(txtPrecioDolar.Text));
}
NumeroRequerimiento = req.Id.ToString();
string url = "Requerimientos.aspx?Id=" + NumeroRequerimiento;
Response.RedirectLocation = url;
}
else
{
foreach (var item in e.InsertValues)
{
db.RequerimientoDetalle.InsertarValoresRequerimientoDetalle(item.NewValues, int.Parse(NumeroRequerimiento.ToString()), decimal.Parse(txtPrecioDolar.Text));
}
foreach (var item in e.UpdateValues)
{
db.RequerimientoDetalle.ActualizarRequerimientoDetalle(item.Keys, item.NewValues);
}
foreach (var item in e.DeleteValues)
{
db.RequerimientoDetalle.EliminarRequerimientoDetalle(item.Keys);
}
}
dgRequerimientoDetalle.DataSource = db.RequerimientoDetalle.ObtenerDetalleRequerimiento(int.Parse(NumeroRequerimiento));
dgRequerimientoDetalle.DataBind();
}
dgRequerimientoDetalle.JSProperties["cpOperacionGrid"] = "Operación realizada con éxito";
}
catch (Exception ex)
{
dgRequerimientoDetalle.JSProperties["cpOperacionGrid"] = "Ha ocurrido un error inesperado: " + ex.Message;
}
e.Handled = true;
}
public async Task <Requerimiento> findById(int Id)
{
if (Id == null || Id == 0)
{
return(new Requerimiento());
}
Requerimiento requerimiento = await dbContext.Requerimientos.FindAsync(Id);
dbContext.Requerimientos.ToList();
return(requerimiento);
}
public ActionResult Edit(Requerimiento requerimiento)
{
if (ModelState.IsValid)
{
db.Entry(requerimiento).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdLiderProyecto = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno", requerimiento.IdLiderProyecto);
ViewBag.IdIdS = new SelectList(db.PersonalesInternos, "IdPersonalInterno", "ApellidoPaterno", requerimiento.IdIdS);
return(View(requerimiento));
}
public async Task <ActionResult> Edit([Bind(Include = "idPK,nombre,id_proyectoFK,fechaInicio,fechaFinalizacion,fechaAsignacion,estado,complejidad,descripcion,duracionEstimada,duracionReal")] Requerimiento requerimiento)
{
if (ModelState.IsValid)
{
db.Entry(requerimiento).State = EntityState.Modified;
await db.SaveChangesAsync( );
return(RedirectToAction("Index", new { projectId = requerimiento.id_proyectoFK }));
}
ViewBag.id_proyectoFK = new SelectList(db.Proyectoes, "idPK", "nombre", requerimiento.id_proyectoFK);
return(View(requerimiento));
}
