Example #1
0
        public ActionResult agregarContrato(Contrato nvoContrato, string nombre_cliente, string btn_cargar, string btn_agregarServicio, string precioPorContrato, string condicion_servicio, string btn_agregarContrato, string tieneTermino_contrato)
        {
            ViewBag.listaPerfiles = perfilTrabajadorModel.getListaPerfilesTrabajadores();
            ViewBag.listaDias = getListaDias();
            ViewBag.listaMeses = getListaMeses();
            ViewBag.listaServicios = Contrato.getAllServicios();
            int idServicio = 0;
            if (Int32.TryParse(nvoContrato.servicioSeleccionado, out idServicio))
            {
                //ViewBag.selectedServicio = idServicio.ToString();
                if (idServicio > 0)
                {
                    ViewBag.precioReferencia = Contrato.getPrecioServicio(idServicio).ToString();
                }
                else
                    ViewBag.precioReferencia = "0";
            }
            else
            {
                ViewBag.precioReferencia = "0";
            }

            if (btn_cargar != null)
            {

                ViewBag.listaServiciosAgregados = Session["listaServicios"];

                if (btn_cargar.Equals("Cargar")) //Se esta cargando un cliente
                {
                    if (ModelState.IsValidField("rutCliente"))
                    {
                        int rut = 0;
                        bool satisf = false;
                        if (!Int32.TryParse(nvoContrato.rutCliente, out rut)) {
                            ModelState.Clear();
                            ModelState.AddModelError("rutCliente", "El rut ingresado no es válido");
                            ViewBag.nombreCliente = "";
                        }
                        else {
                            ViewBag.nombreCliente = Contrato.getNombreCliente(rut, out satisf);
                            if (!satisf)
                            {
                                ModelState.Clear();
                                ModelState.AddModelError("rutCliente", "El rut insertado no existe");
                            }
                        }
                    }
                    else
                    {
                        string mensaje = "El rut ingresado no es válido";
                        ModelState.Clear();
                        ModelState.AddModelError("rutCliente", mensaje);
                    }

                }
            }
            else if (btn_agregarServicio != null)
            {
                ModelState.Clear();

                int enteroTemp = 0;
                if (!Int32.TryParse(nvoContrato.servicioSeleccionado, out enteroTemp))
                {
                    string mensaje = "El servicio seleccionado no es válido";
                    ModelState.AddModelError("servicioSeleccionado", mensaje);
                }
                else if (enteroTemp < 0)
                {
                    string mensaje = "El servicio seleccionado no es válido";
                    ModelState.AddModelError("servicioSeleccionado", mensaje);

                }
                else if (!Int32.TryParse(precioPorContrato, out enteroTemp))
                {
                    string mensaje = "El precio del servicio no es válido";
                    ModelState.AddModelError("precioPorContrato", mensaje);
                }
                else if (enteroTemp < 0)
                {
                    string mensaje = "El precio del servicio no es válido";
                    ModelState.AddModelError("precioPorContrato", mensaje);
                }
                else
                {

                    List<ServicioListado> listaTemp = null;
                    if (Session["listaServicios"] == null)
                    {
                        listaTemp = new List<ServicioListado>();
                        Session["listaServicios"] = listaTemp;
                    }
                    else
                    {
                        listaTemp = (List<ServicioListado>)Session["listaServicios"];
                    }

                    idServicio = 0;
                    if (Int32.TryParse(nvoContrato.servicioSeleccionado, out idServicio))
                    {
                        //ViewBag.selectedServicio = idServicio.ToString();
                        ViewBag.precioReferencia = Contrato.getPrecioServicio(idServicio).ToString();

                    }
                    else
                    {
                        ViewBag.precioReferencia = "0";
                    }

                    ServicioListado servicioNvo = new ServicioListado();
                    servicioNvo.descripcion = condicion_servicio;
                    int idServicioSeleccionado = 0;
                    Int32.TryParse(nvoContrato.servicioSeleccionado, out idServicioSeleccionado);
                    servicioNvo.nombre_servicio = ServicioListado.getNombreServicio(idServicioSeleccionado);
                    servicioNvo.precio_acordado = precioPorContrato;
                    servicioNvo.id_servicio = nvoContrato.servicioSeleccionado;
                    bool esta = false;
                    foreach (ServicioListado servTemp in listaTemp)
                    {
                        if (servTemp.id_servicio.Equals(servicioNvo.id_servicio)) {
                            esta = true;
                        }
                    }
                    if (esta)
                    {
                        ModelState.AddModelError("servicioSeleccionado", "El servicio seleccionado ya estaba agregado");
                    }
                    else
                    {
                        listaTemp.Add(servicioNvo);
                    }
                    ViewBag.listaServiciosAgregados = listaTemp;
                }
            }
            else if (btn_agregarContrato != null) //Agrego el contrato
            {
                if (ModelState.IsValidField("rutCliente"))
                {
                    int rut = 0;
                    bool satisf = false;
                    if (!Int32.TryParse(nvoContrato.rutCliente, out rut))
                    {
                        ModelState.Clear();
                        ModelState.AddModelError("rutCliente", "El rut ingresado no es válido");
                        ViewBag.nombreCliente = "";
                    }
                    else
                    {
                        ViewBag.nombreCliente = Contrato.getNombreCliente(rut, out satisf);
                        if (!satisf)
                        {
                            ModelState.Clear();
                            ModelState.AddModelError("rutCliente", "El rut insertado no existe");
                        }
                        else
                        {
                            List<ServicioListado> listaTemp;
                            if (Session["listaServicios"] == null)
                            {
                                ViewBag.respuestaPost = "No posee una lista de servicios para el nuevo contrato";

                            }
                            else if (((List<ServicioListado>)Session["listaServicios"]).Count == 0)
                            {
                                ViewBag.respuestaPost = "Posee una lista de servicios para el nuevo contrato vacia";

                            }
                            else
                            {
                                listaTemp = (List<ServicioListado>)Session["listaServicios"];

                                //ahora compruebo las fechas de contrato
                                int agnoInt = 0;
                                if (Int32.TryParse(nvoContrato.agno_ini_contrato, out agnoInt))
                                {
                                    if ((agnoInt >= 1900) && (agnoInt <= 2100))
                                    {
                                        string fecha_ini = nvoContrato.dia_ini_contrato + "-" + nvoContrato.mes_ini_contrato + "-" + nvoContrato.agno_ini_contrato;
                                        string fecha_fin = null;
                                        //Camino CORRECTO HASTA AHORA
                                        if (tieneTermino_contrato.Contains("true"))
                                        {
                                            //Camino correcto, tomo en cuenta la fecha de fin del contrato
                                            fecha_fin = nvoContrato.dia_caducidad_contrato + "-" + nvoContrato.mes_caducidad_contrato + "-" + nvoContrato.agno_caducidad_contrato;
                                        }
                                        else
                                        {
                                            //Camino correcto, no tomo en cuenta la fecha de fin de contrato
                                        }
                                        ViewBag.respuestaPost = "Se ha creado el contrato";
                                        if (Contrato.insertContrato(rut, fecha_ini, fecha_fin, nvoContrato.breve_descripcion, listaTemp) <= 0)
                                        {
                                            ViewBag.respuestaPost = "No se ha podido realizar la creación del contrato";
                                        }

                                        //CAMINO FELIZ
                                        return RedirectToAction("Index", "home");

                                    }
                                    else
                                    {
                                        ModelState.AddModelError("agno_ini_contrato", "El año de inicio de contrato no está en el rango");

                                    }
                                }
                                else
                                {
                                    ModelState.AddModelError("agno_ini_contrato", "El año de inicio de contrato no es válido");
                                }
                            }
                        }
                    }
                }
                else
                {
                    string mensaje = "El rut ingresado no es válido";
                    ModelState.Clear();
                    ModelState.AddModelError("rutCliente", mensaje);
                }

                List<ServicioListado> listaTemp2 = null;
                if (Session["listaServicios"] == null)
                {
                    listaTemp2 = new List<ServicioListado>();
                    Session["listaServicios"] = listaTemp2;
                }
                else
                {
                    listaTemp2 = (List<ServicioListado>)Session["listaServicios"];
                }
                ViewBag.listaServiciosAgregados = listaTemp2;
            }
            else
            {
                //Verifico si es un botón "quitar"
                NameValueCollection col = Request.Params;
                int idServ = 0;
                string nombreParam = "", idServStr;
                for (int i = 0; i < Request.Params.Count; i++)
                {

                    nombreParam = col.GetKey(i); //Con esto accedo al nombre del parámetro
                    if (nombreParam.Contains("quitar_")) //Con esto omito los parámetros que no me importan
                    {
                        if (Session["listaServicios"] != null)
                        {

                            idServStr = nombreParam.Substring("quitar_".Length);
                            if (Int32.TryParse(idServStr, out idServ))
                            {
                                List<ServicioListado> listaTemp = (List<ServicioListado>)Session["listaServicios"];
                                bool encontrado = false;
                                int posicion = 0;
                                foreach (ServicioListado temp in listaTemp)
                                {
                                    if (temp.id_servicio.Equals(idServStr))
                                    {
                                        encontrado = true;
                                        break;
                                    }
                                    posicion++;
                                }

                                if (encontrado)
                                {
                                    listaTemp.RemoveAt(posicion);
                                    ViewBag.respuestaPost = "Se ha quitado el servicio de la lista de servicios para el contrato";
                                }
                                else
                                {
                                    ViewBag.respuestaPost = "El servicio no estaba agregado a la lista de servicios para el contrato";
                                }
                            }
                        }
                    }
                }

                ViewBag.listaServiciosAgregados = Session["listaServicios"];

                ModelState.Clear();
                idServicio = 0;
                if (Int32.TryParse(nvoContrato.servicioSeleccionado, out idServicio))
                {
                    //ViewBag.selectedServicio = idServicio.ToString();
                    ViewBag.precioReferencia = Contrato.getPrecioServicio(idServicio).ToString();
                }
                else
                {
                    ViewBag.precioReferencia = "0";
                }

                return View(nvoContrato);
            }
            return View(nvoContrato);
        }
Example #2
0
        public static List<ServicioListado> getServiciosDelContrato(int idContrato)
        {
            List<ServicioListado> res = new List<ServicioListado>();
            ServicioListado temp;
            NpgsqlDataReaderWithConection lector = null;
            try
            {
                string query = "SELECT id_contrato, id_servicio, nombre_servicio, precio_acordado, detalle_condicion FROM contrato NATURAL JOIN precio_servicio NATURAL JOIN servicio WHERE id_contrato=" + idContrato;
                lector = DBConector.SELECT(query);

                while (lector.Read())
                {
                    temp = new ServicioListado();
                    temp.id_servicio = lector["id_servicio"];
                    temp.nombre_servicio = lector["nombre_servicio"];
                    temp.precio_acordado = lector["precio_acordado"];
                    temp.descripcion = lector["detalle_condicion"];

                    res.Add(temp);
                }
            }
            catch (Exception)
            {
            }
            if (lector != null)
            {
                lector.CloseTodo();
            }
            return res;
        }
Example #3
0
        public ActionResult ingresoOT(OrdenTrabajoModel ordenTrabajo, string btn_crear_ot, string btn_agregarServicio)
        {
            ViewBag.listaDias = getListaDias();
            ViewBag.listaMeses = getListaMeses();

            ViewBag.listaRuts = OrdenTrabajoModel.getClientes();
            List<SelectListItem> contratosSelectedList = new List<SelectListItem>();
            List<Contrato> contratos;

            List<ServicioListado> listaAgregadosSesion;
            if (Session["listaServiciosNvaOT"] == null)
            {
                listaAgregadosSesion = new List<ServicioListado>();
            }
            else
            {
                listaAgregadosSesion = (List<ServicioListado>)Session["listaServiciosNvaOT"];
            }

            int id_servicio = 0;
            if (btn_crear_ot == null) //Si se presionó cualquier botón distinto del de crear la OT
            {
                ModelState.Clear();
                if (btn_agregarServicio != null) {
                    ServicioListado nvoServ = new ServicioListado();

                    nvoServ.descripcion = ordenTrabajo.breve_descripcion;
                    nvoServ.id_servicio = ordenTrabajo.servicioSeleccionado;

                    if (!Int32.TryParse(nvoServ.id_servicio, out id_servicio))
                    {
                        ViewBag.RespuestaPost = "No se ha podido cargar el nombre del servicio";
                        ViewBag.tipoRespuestaPost = "error";
                    }

                    nvoServ.nombre_servicio = ServicioListado.getNombreServicio(id_servicio);
                    nvoServ.precio_acordado = ordenTrabajo.precioFinal;
                    nvoServ.cantidad = ordenTrabajo.cantidadDelServicio;

                    //Controlo que el servicio no haya sido agregado anteriormente
                    bool yaAgregado = false;
                    foreach (ServicioListado servTemp in listaAgregadosSesion)
                    {
                        if (servTemp.id_servicio.Equals(nvoServ.id_servicio))
                        {
                            ViewBag.RespuestaPost = "Ya tiene agregado el servicio";
                            ViewBag.tipoRespuestaPost = "advertencia";
                            yaAgregado = true;
                        }
                    }

                    if (!yaAgregado)
                    {
                        listaAgregadosSesion.Add(nvoServ);
                    }
                    Session["listaServiciosNvaOT"] = listaAgregadosSesion;

                }
                else {

                    //Quito de la lista de agregados en caso que se haya presionado un botón quitar
                    NameValueCollection col = Request.Params;
                    string nombreParam = "", id_servicioStr;
                    for (int i = 0; i < Request.Params.Count; i++)
                    {

                        nombreParam = col.GetKey(i); //Con esto accedo al nombre del parámetro
                        if (nombreParam.Contains("quitar_")) //Con esto omito los parámetros que no me importan
                        {
                            if (Session["listaServiciosNvaOT"] != null)
                            {
                                id_servicioStr = nombreParam.Substring("quitar_".Length);

                                if (Int32.TryParse(id_servicioStr, out id_servicio))
                                {
                                    bool re = false;
                                    List<ServicioListado> listaTemp = (List<ServicioListado>)Session["listaServiciosNvaOT"];
                                    int pos = 0;
                                    foreach (ServicioListado t in listaTemp)
                                    {
                                        if (t.id_servicio.Equals(id_servicioStr))
                                        {
                                            re = true;
                                            break;
                                        }
                                        pos++;
                                    }

                                    if (re)
                                    {
                                        listaTemp.RemoveAt(pos);
                                        ViewBag.respuestaPost = "Se ha quitado el servicio de la lista de servicio de la orden de trabajo";
                                        ViewBag.tipoRespuetaPost = "information";
                                    }
                                    else
                                    {
                                        ViewBag.respuestaPost = "El servicio que desea quitar no se encontraba en la lista";
                                        ViewBag.tipoRespuetaPost = "error";
                                    }
                                }

                            }
                        }
                    }
                }
            }
            else //Se presionó el botón crear OT
            {
                string respuesta = "";
                if (Session["listaServiciosNvaOT"] != null)
                {
                    if (listaAgregadosSesion.Count == 0)
                    {
                        respuesta = "No ha agregado servicios a la orden de trabajo";
                        ViewBag.tipoRespuestaPost = "informacion";
                    }
                    else
                    {
                        //Camino feliz
                        int enteroTemp;
                        bool satisfactorio = true;
                        if (!(satisfactorio = satisfactorio && Int32.TryParse(ordenTrabajo.agno_ini_ot, out enteroTemp)))
                        {
                            ModelState.AddModelError("agno_ini_ot", "El año de inicio de la orden de trabajo no es válido");
                        }
                        if (!(satisfactorio = satisfactorio && Int32.TryParse(ordenTrabajo.agno_fin_ot, out enteroTemp)))
                        {
                            ModelState.AddModelError("agno_fin_ot", "El año de finalización de la orden de trabajo no es válido");
                        }
                        if (!(satisfactorio = satisfactorio && Int32.TryParse(ordenTrabajo.nro_orden_segun_cliente, out enteroTemp)))
                        {
                            ModelState.AddModelError("nro_orden_segun_cliente", "El N° de la orden de trabajo no es válido");
                        }
                        if (ModelState.IsValid)
                        {
                            respuesta = OrdenTrabajoModel.insertOrdenTrabajo(ordenTrabajo, listaAgregadosSesion);
                            ViewBag.tipoRespuestaPost = "informacion";
                        }

                    }
                }
                else
                {
                    respuesta = "No ha agregado servicios a la orden de trabajo";
                    ViewBag.tipoRespuestaPost = "informacion";
                }

                ViewBag.respuestaPost = respuesta;
            }

            //cargo los contratos que correspondan
            if (Int32.TryParse(ordenTrabajo.cliente, out id_servicio))
            {
                contratos = OrdenTrabajoModel.getContratosSegunCliente(id_servicio);
            }
            else
            {
                contratosSelectedList = new List<SelectListItem>();
                ViewBag.RespuestaPost = "Problemas con el rut del cliente";
                ViewBag.tipoRespuestaPost = "error";
                contratos = new List<Contrato>();
            }
            ordenTrabajo.descripcion_contrato = "";
            bool coincideAlguno = false;
            foreach (Contrato t in contratos)
            {
                if (ordenTrabajo.contrato != null)
                {
                    if (ordenTrabajo.contrato.Equals(t.id_contrato.ToString()))
                    {
                        coincideAlguno = true;
                        ordenTrabajo.descripcion_contrato = t.breve_descripcion;
                    }
                }
                contratosSelectedList.Add(new SelectListItem
                {
                    Text = t.id_contrato,
                    Value = t.id_contrato
                });
            }
            if (!coincideAlguno && contratos.Count > 0)
            {
                ordenTrabajo.contrato = contratos[0].id_contrato;
                ordenTrabajo.descripcion_contrato = contratos[0].breve_descripcion;
            }
            else if (!coincideAlguno)
            {
                ordenTrabajo.descripcion_contrato = "";
            }

            //Cargo la lista de servicios para el contrato y su precio correspondiente
            int id_contrato_seleccionado = -1;
            Int32.TryParse(ordenTrabajo.contrato, out id_contrato_seleccionado);
            List<SelectListItem> serviciosDelContrato = servicioContrato.getServiciosDeContrato(id_contrato_seleccionado);
            ViewBag.listaServicios = serviciosDelContrato;
            coincideAlguno = false;
            foreach (SelectListItem t in serviciosDelContrato)
            {
                if (ordenTrabajo.servicioSeleccionado != null)
                {
                    if (ordenTrabajo.servicioSeleccionado.Equals(t.Value))
                    {
                        coincideAlguno = true;
                        ordenTrabajo.precioReferenciaContrato = servicioContrato.getPrecioAcordadoServicio(Int32.Parse(t.Value), id_contrato_seleccionado).ToString();
                        ordenTrabajo.precioFinal = ordenTrabajo.precioReferenciaContrato;
                    }
                }
            }
            if (!coincideAlguno && contratos.Count > 0)
            {
                ordenTrabajo.servicioSeleccionado = serviciosDelContrato[0].Value;
                ordenTrabajo.precioReferenciaContrato = servicioContrato.getPrecioAcordadoServicio(Int32.Parse(serviciosDelContrato[0].Value), id_contrato_seleccionado).ToString();
                ordenTrabajo.precioFinal = ordenTrabajo.precioReferenciaContrato;
            }
            else if (!coincideAlguno)
            {
                ordenTrabajo.precioReferenciaContrato = "0";
                ordenTrabajo.precioFinal = "0";
            }

            ViewBag.listaContratos = contratosSelectedList;
            ViewBag.listaServiciosAgregados = listaAgregadosSesion;

            return View(ordenTrabajo);
        }