public ActionResult Registrar(CitaEN citaEN, int cboServicios, int cboTalleres, int cboVehiculos)
        {
            try
            {                                
                if (cboVehiculos == 0)
                {
                    ModelState.AddModelError("MensajeError", "Seleccione Vehículo");
                    return View(citaEN);
                }
                else if (cboServicios == 0 )
                {
                    ModelState.AddModelError("MensajeError", "Seleccione Servicio");
                    return View(citaEN);
                }
                else if (cboTalleres == 0)
                {
                    ModelState.AddModelError("MensajeError", "Seleccione Talleres");
                    return View(citaEN);
                }

                if (ModelState.IsValid)
                {
                    try
                    {                        
                        citaEN.Servicio = new ServicioEN { Codigo = cboServicios };
                        citaEN.Usuario = new UsuarioEN { Codigo = FachadaSesion.Usuario.Codigo };
                        citaEN.Vehiculo = new VehiculoEN { Codigo = cboVehiculos };
                        citaEN.Taller = new TallerEN { Codigo = cboTalleres };

                        int anio = Convert.ToInt32(citaEN.Fecha.Substring(6, 4));
                        int mes = Convert.ToInt32(citaEN.Fecha.Substring(3, 2));
                        int dia = Convert.ToInt32(citaEN.Fecha.Substring(0, 2));
                        citaEN.HoraInicio = new DateTime(anio, mes, dia, citaEN.RangoHora, 0, 0);

                        citaEN = GestionCitasProxy.CrearCita(citaEN);
                    }
                    catch (FaultException<RepetidoException> fe)
                    {
                        ModelState.AddModelError("MensajeError", fe.Message + ": " + fe.Detail.Mensaje);
                        return View(citaEN);
                    }

                }
                return RedirectToAction("Index");
            }
            catch
            {
                ModelState.AddModelError("MensajeError", "Se registro correctamente. Verifique luego.");
                return RedirectToAction("Index");
            }
        }
        public CitaEN DarBajaCita(CitaEN citaEN)
        {
            CitaEN citaDarBaja = null;
            CitaEN citaDarBaja2 = null;
            try
            {
                int iCodigoCita = Convert.ToInt32(citaEN.Codigo);
                citaDarBaja = atiendeCitaDao.Obtener(iCodigoCita);

                citaDarBaja.Estado = 3;
                citaDarBaja2 = atiendeCitaDao.Modificar(citaDarBaja);
            }
            catch (Exception ex)
            {
                throw new WebFaultException<string>(ex.Message, HttpStatusCode.InternalServerError);
            }

            return citaDarBaja2;
        }
        public CitaEN DarAltaCita(CitaEN citaEN)
        {
            CitaEN citaAlta = null;
            CitaEN citaDarAlta = null;
            int iCodigoCita = Convert.ToInt32(citaEN.Codigo);
            try
            {
                citaAlta = atiendeCitaDao.Obtener(iCodigoCita);
            }
            catch (Exception ex)
            {
                throw new WebFaultException<string>(ex.Message, HttpStatusCode.InternalServerError);
            }

            DateTime fecha = Convert.ToDateTime(citaAlta.Fecha);

            if (DateTime.Now.Date < fecha.Date)
            {
                throw new WebFaultException<string>("No es posible el alta. La fecha de cita es posterior a la fecha actual. Se debe dar alta el mismo dia de la cita.", HttpStatusCode.InternalServerError);
            }

            if (DateTime.Now.Date > fecha.Date.AddDays(1))
            {
                throw new WebFaultException<string>("No es posible el alta, debido a que ya se ha vencido el tiempo maximo de alta de cita (01 dias).", HttpStatusCode.InternalServerError);
            }

            try
            {
                citaAlta.Estado = 2;
                citaDarAlta = atiendeCitaDao.Modificar(citaAlta);
            }
            catch (Exception ex)
            {
                throw new WebFaultException<string>(ex.Message, HttpStatusCode.InternalServerError);
            }

            return citaDarAlta;
        }
        public CitaEN CrearCita(CitaEN citaCrear)
        {
            CitaEN citaCreada = null;
            string codigoNroCita = GenerarCodigoCitaNuevo();
            citaCrear.NroCita = codigoNroCita;

            int anio = Convert.ToInt32(citaCrear.Fecha.Substring(6, 4));
            int mes = Convert.ToInt32(citaCrear.Fecha.Substring(3, 2));
            int dia = Convert.ToInt32(citaCrear.Fecha.Substring(0, 2));
            int hhInicio;
            int hhFinal; int mmFinal = 0; int ssFinal = 0;
            DateTime horaFinal;
            DateTime fechaCita = Convert.ToDateTime(citaCrear.Fecha);

            hhInicio = citaCrear.HoraInicio.Hour;

            ServicioEN servicioAsociado = null;
            try
            {
                //Obtener hora de termino calculada
                ServicioService proxy = new ServicioService();
                servicioAsociado = proxy.ObtenerServicio(citaCrear.Servicio.Codigo);
            }
            catch
            {
                servicioAsociado = new ServicioEN() { Codigo = citaCrear.Servicio.Codigo, TiempoEstimado = 3 };
            }

            hhFinal = hhInicio + servicioAsociado.TiempoEstimado;

            horaFinal = new DateTime(anio, mes, dia, hhInicio, mmFinal, ssFinal);
            citaCrear.HoraFin = horaFinal.AddHours(hhFinal);

            //Estado
            citaCrear.Estado = 1; //Pendiente

            if (fechaCita.Date < DateTime.Now.Date)
            {
                throw new FaultException<RepetidoException>(new RepetidoException()
                {
                    Codigo = 1,
                    Mensaje = "La fecha seleccionada de la cita es incorrecta."
                },
                new FaultReason("Validación de negocio"));
            }

            if (citaCrear.HoraInicio <= DateTime.Now.AddHours(1))
            {
                throw new FaultException<RepetidoException>(new RepetidoException()
                {
                    Codigo = 2,
                    Mensaje = "Las citas de servicios son registradas con 1 hora de anticipacion, por favor elija otro horario disponible."
                },
                new FaultReason("Validación de negocio"));
            }


            try
            {

                //validar si el horario ya no esta disponible
                bool bEstaDisponibleHorario = false;
                bEstaDisponibleHorario = ValidarFechaHoraCitaXTaller(citaCrear.Fecha,
                                                                      citaCrear.HoraInicio,
                                                                      citaCrear.HoraFin,
                                                                      citaCrear.Taller.Codigo, citaCrear.Usuario.Codigo);

                if (bEstaDisponibleHorario)
                {
                    throw new FaultException<RepetidoException>(new RepetidoException()
                    {
                        Codigo = 3,
                        Mensaje = "La fecha y hora seleccionada no esta disponible."
                    },
                    new FaultReason("Validación de negocio"));
                }

                string strConectado = ConfigurationManager.AppSettings["ModoDesconectado"];
                if (strConectado.Equals("0"))
                {
                    throw new Exception("Modo Desconectado -  Colas");
                }

                citaCreada = CitaDAO.Crear(citaCrear);
            }
            catch (Exception ex)
            {
                citaCreada = citaCrear;
                string rutacola = @".\private$\ColaCitas";
                if (!MessageQueue.Exists(rutacola))
                {
                    MessageQueue.Create(rutacola);
                }
                MessageQueue cola = new MessageQueue(rutacola);

                Message mensaje = new Message();
                mensaje.Label = "Cola Usuario : " + citaCrear.Usuario.Usuario;
                mensaje.Body = citaCrear;
                cola.Send(mensaje);
            }
            return citaCreada;
        }
 public CitaEN ModificarCita(CitaEN citaModificar)
 {
     CitaEN citaExistente = CitaDAO.Obtener(citaModificar.Codigo);
     return CitaDAO.Modificar(citaModificar);
 }
        public void CrearCitaTest()
        {
            CitaEN citaCreada = null;
            VehiculoEN vehiculoAsignado = null;
            TallerEN tallerAsignado = null;
            UsuarioEN usuarioAsignado = null;
            ServicioEN servicioAsignado = null;

            GestionCitasWS.GestionCitasServiceClient _proxy = new GestionCitasWS.GestionCitasServiceClient();

            tallerAsignado = new TallerEN()
            {
                Codigo = 2
            };

            vehiculoAsignado = new VehiculoEN()
            {
                Codigo = 1
            };

            usuarioAsignado = new UsuarioEN()
            {
                Codigo = 2
            };

            servicioAsignado = new ServicioEN()
            {
                Codigo = 1
            };

            var fecha = "10/02/2016";
            int anio = Convert.ToInt32(fecha.Substring(6, 4));
            int mes = Convert.ToInt32(fecha.Substring(3, 2));
            int dia = Convert.ToInt32(fecha.Substring(0, 2));
            int hh = 13; //8  - 9 - 14 - 15 - 16
            int mm = 0;
            int ss = 0;

            CitaEN citaACrear = new CitaEN()
            {
                Fecha = fecha,
                HoraInicio = new DateTime(anio, mes,dia, hh,mm,ss),
                Observacion = "Pendiente de pago",
                Vehiculo = vehiculoAsignado,
                Taller = tallerAsignado,
                Servicio = servicioAsignado,
                Usuario = usuarioAsignado
            };

            try
            {
                citaCreada = _proxy.CrearCita(citaACrear);
                Assert.AreNotEqual(null, citaCreada);
            }
            catch (FaultException<RepetidoException> fe)
            {
                if (fe.Detail.Codigo == 1)
                {
                    Assert.AreEqual(1, fe.Detail.Codigo);
                    Assert.AreEqual("La fecha seleccionada de la cita es incorrecta.", fe.Detail.Mensaje);
                    Assert.AreEqual("Validación de negocio", fe.Reason.ToString());
                }
                else if (fe.Detail.Codigo == 2)
                {
                    Assert.AreEqual(2, fe.Detail.Codigo);
                    Assert.AreEqual("Las citas de servicios son registradas con 1 hora de anticipacion, por favor elija otro horario disponible.", fe.Detail.Mensaje);
                    Assert.AreEqual("Validación de negocio", fe.Reason.ToString());
                }
                else if (fe.Detail.Codigo == 3)
                {
                    Assert.AreEqual(3, fe.Detail.Codigo);
                    Assert.AreEqual("La fecha y hora seleccionada no esta disponible.", fe.Detail.Mensaje);
                    Assert.AreEqual("Validación de negocio", fe.Reason.ToString());
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        public ActionResult DarBajaCita(int id)
        {
            if (ModelState.IsValid)
            {
                CitaEN citaEN = new CitaEN() { Codigo = id};
                JavaScriptSerializer serializer = new JavaScriptSerializer();
                string postdata = serializer.Serialize(citaEN); ;
                byte[] data = Encoding.UTF8.GetBytes(postdata);
                HttpWebRequest req = (HttpWebRequest)WebRequest
                    .Create("http://localhost:4157/AtencionCitaService.svc/Citas");
                req.Method = "PUT";
                req.ContentLength = data.Length;
                req.ContentType = "application/json";
                var reqStream = req.GetRequestStream();
                reqStream.Write(data, 0, data.Length);
                HttpWebResponse res = null;
                try
                {
                    res = (HttpWebResponse)req.GetResponse();
                    StreamReader reader = new StreamReader(res.GetResponseStream());
                    string citaAltaJson = reader.ReadToEnd();
                    JavaScriptSerializer js = new JavaScriptSerializer();
                    CitaEN citaEnAlta = js.Deserialize<CitaEN>(citaAltaJson);
                }
                catch (WebException e)
                {
                    HttpStatusCode code = ((HttpWebResponse)e.Response).StatusCode;
                    string message = ((HttpWebResponse)e.Response).StatusDescription;
                    StreamReader reader = new StreamReader(e.Response.GetResponseStream());
                    string error = reader.ReadToEnd();
                    JavaScriptSerializer js = new JavaScriptSerializer();
                    string mensaje = js.Deserialize<string>(error);

                    ModelState.AddModelError("MensajeError", mensaje);
                    return View(citaEN);
                }
            }
            return RedirectToAction("MisCitas");
        }
        public ActionResult Editar(CitaEN citaEN, int cboServicio, int cboTaller, int cboUsuario, int cboVehiculo)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    citaEN.Servicio = new ServicioEN { Codigo = cboServicio };
                    citaEN.Usuario = new UsuarioEN { Codigo = cboUsuario };
                    citaEN.Vehiculo = new VehiculoEN { Codigo = cboVehiculo };
                    citaEN.Taller = new TallerEN { Codigo = cboTaller };
                    GestionCitasProxy.ModificarCita(citaEN);
                }
                catch (FaultException<RepetidoException> fe)
                {
                    ModelState.AddModelError("MensajeError", fe.Message + ": " + fe.Detail.Mensaje);
                    return View(citaEN);
                }
            }

            return RedirectToAction("Index");
        }
 //
 // GET: /GestionCitas/Editar/5
 public ActionResult Editar(int id)
 {
     CitaEN citaEN = new CitaEN();
     if (ModelState.IsValid)
     {
         try
         {
             citaEN = GestionCitasProxy.ObtenerCita(id);
         }
         catch (FaultException<RepetidoException> fe)
         {
             ModelState.AddModelError("MensajeError", fe.Message + ": " + fe.Detail.Mensaje);
         }
     }
     return View(citaEN);
 }