public ActionResult AgregarClasificacionAgencias(string id, string forma, Agencias agencia)
        {
            if (!string.IsNullOrEmpty(forma))
            {
                //agregar clasificación para agencia individual
                if (forma.Equals("individual"))
                {
                    //obteniendo numero de agencia
                    string num = "";
                    if (!string.IsNullOrEmpty(id))
                    {
                        string[] ids = id.Split('-');
                        num = ids[0].Trim();
                    }

                    //buscar agencia
                    if (!string.IsNullOrEmpty(num))
                    {
                        try
                        {
                            Agencias a = db.Agencias.Find(int.Parse(num));
                            V_Agencias v = db.VAgencias.Find(int.Parse(num));
                            //opciones de clasificacion
                            var clasificaciones = from c in db.Local_Clasificacion_Agencia select c.clasificacion + " ("+c.id_clasificacion+")";
                            a.listaClasificacion = new SelectList(clasificaciones);

                            if (a != null)
                            {
                                a.v_agencia = v;
                                a.listaAgencias = new SelectList(claseAgencias.GetAgencias());
                                return View(a);
                            }
                            ViewBag.Error = "El Agente no existe";
                            return View();
                        }
                        catch (Exception e)
                        {
                            TempData["Errores"] = "Ha ocurrido un problema.  Intente de nuevo o contacte al administrador.";
                            return RedirectToAction("Error");
                        }

                    }
                    return RedirectToAction("ClasificacionAgencias");

                }
                else if (forma.Equals("actualizar"))
                {
                    if (!string.IsNullOrEmpty(agencia.clasificacionSeleccionada))
                    {
                        //buscar clasificacion
                        var c = agencia.clasificacionSeleccionada.Split('(',')');
                        var clasificacionNueva = c[1];
                        if (!string.IsNullOrEmpty(clasificacionNueva))
                        {
                            //buscar que la clasificacion exista
                            var clasificaciones = from ca in db.Local_Clasificacion_Agencia select ca.id_clasificacion;
                            if (clasificaciones.Contains(clasificacionNueva))
                            {
                                Agencias a = db.Agencias.Find(agencia.NUMERO_AGENCIA);
                                if (a != null)
                                {
                                    //obteniendo usuario
                                    string domainUser = User.Identity.Name;
                                    string[] parts = domainUser.Split('\\');
                                    string username = parts[1];

                                    //historial de clasificacion
                                    local_historial_clasificacion lhc = new local_historial_clasificacion();
                                    lhc.numero_agencia = a.NUMERO_AGENCIA;
                                    lhc.fechaActualizacion = DateTime.Now;
                                    lhc.usuario = username;
                                    lhc.clasificacion = a.Local_Clasificacion;
                                    lhc.nuevaClasificacion = clasificacionNueva;
                                    db.local_historial_clasificacion.Add(lhc);

                                    a.Local_Clasificacion = clasificacionNueva;
                                    a.listaAgencias = new SelectList(claseAgencias.GetAgencias());

                                    db.SaveChanges();
                                    ViewBag.Success = "Se ha actualizado exitosamente.";
                                    return View(a);
                                }
                                else
                                {
                                    ViewBag.mensaje = "Esta agencia no existe";
                                    return View(a);
                                }
                            }
                            else
                            {
                                ViewBag.mensaje = "Esta clasificación no existe";
                                return View(new Agencias());
                            }
                        }
                    }
                    else
                    {
                        Agencias a = db.Agencias.Find(agencia.NUMERO_AGENCIA);
                        V_Agencias v = db.VAgencias.Find(agencia.NUMERO_AGENCIA);
                        a.listaAgencias = new SelectList(claseAgencias.GetAgencias());
                        a.v_agencia = v;
                        //opciones de clasificacion
                        var clasificaciones = from c in db.Local_Clasificacion_Agencia select c.clasificacion + "(" + c.id_clasificacion + ")";
                        a.listaClasificacion = new SelectList(clasificaciones);
                        ModelState.AddModelError("diaSeleccionado", "Debe seleccionar un día");
                        return View(a);
                    }
                }
                //agregar dia para multiples agencias
                else
                {
                    return RedirectToAction("ClasificacionAgencias");
                }
            }
            else
            {
                return RedirectToAction("ClasificacionAgencias");
            }
            return RedirectToAction("ClasificacionAgencias");
        }
        public ActionResult AgregarClasificacionAgencias(HttpPostedFileBase file)
        {
            //obteniendo usuario
            string domainUser = User.Identity.Name;
            string[] parts = domainUser.Split('\\');
            string username = parts[1];

            List<string> errores = new List<string>();
            try
            {
                //verificar que no sea nulo
                if (file != null)
                {
                    if (file.ContentLength > 0)
                    {
                        var filename = Path.GetFileName(file.FileName);
                        var path = Path.Combine(Server.MapPath("~/App_Data/uploads"), filename);
                        file.SaveAs(path);
                        string num_agencia, clasificacion;
                        num_agencia = clasificacion = "";
                        int numeroAgencia = 0;
                        int successCount = 0;

                        var connString = "";

                        try
                        {
                            var strFileType = Path.GetExtension(path).ToLower();

                            //Connection String to Excel Workbook for differente extensions
                            if (strFileType.Trim() == ".xls")
                            {
                                connString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + path + ";Extended Properties=\"Excel 8.0;HDR=Yes;IMEX=2\"";
                            }
                            else if (strFileType.Trim() == ".xlsx")
                            {
                                connString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + path + ";Extended Properties=\"Excel 12.0;HDR=Yes;IMEX=2\"";
                            }

                            using (OleDbConnection connection = new OleDbConnection(connString))
                            {
                                //abriendo conexion
                                connection.Open();

                                //obteniendo nombre de la tabla
                                //obtener nombre de la tabla
                                System.Data.DataTable dbSchema = connection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
                                string sheet = dbSchema.Rows[0]["TABLE_NAME"].ToString();
                                string queryRead = "SELECT * FROM [" + sheet + "]";  //QUERY LECTURA

                                OleDbCommand cmdRead = new OleDbCommand(queryRead, connection);

                                //leyendo el sheet
                                OleDbDataReader reader = cmdRead.ExecuteReader();
                                while (reader.Read())
                                {
                                    //leyendo filas columna por columna
                                    num_agencia = reader[0].ToString();
                                    clasificacion = reader[1].ToString();

                                    //verificar que ninguno de los campos este vacio
                                    if (!string.IsNullOrEmpty(clasificacion) && !string.IsNullOrEmpty(clasificacion))
                                    {
                                        //verificar sea agencia válida
                                        if (num_agencia.StartsWith("20") && num_agencia.Length == 6)
                                        {
                                            //buscar que la clasificación sea correcta
                                            var clasificaciones = from ca in db.Local_Clasificacion_Agencia select ca.id_clasificacion;
                                            if (clasificaciones.Contains(clasificacion.ToUpper()))
                                            {
                                                //buscar la agencia
                                                numeroAgencia = int.Parse(num_agencia);
                                                var agencia = db.Agencias.Find(numeroAgencia);
                                                if (agencia != null)
                                                {
                                                    var clasificacionVieja = agencia.Local_Clasificacion;
                                                    if (!clasificacionVieja.Equals(clasificacion))
                                                    {
                                                        agencia.Local_Clasificacion = clasificacion;
                                                        successCount++;

                                                        //historial de clasificacion
                                                        local_historial_clasificacion lhc = new local_historial_clasificacion();
                                                        lhc.numero_agencia = numeroAgencia;
                                                        lhc.fechaActualizacion = DateTime.Now;
                                                        lhc.usuario = username;
                                                        lhc.clasificacion = clasificacionVieja;
                                                        lhc.nuevaClasificacion = clasificacion;
                                                        db.local_historial_clasificacion.Add(lhc);
                                                    }
                                                }
                                                else
                                                {
                                                    errores.Add("No existe la agencia " + num_agencia);
                                                }
                                            }
                                            else
                                            {
                                                errores.Add("La clasificación " + clasificacion + " a asignar a la agencia " + num_agencia + " no es correcta.");
                                            }
                                        }
                                        else
                                        {
                                            errores.Add(num_agencia + " No está en el formato correcto.");
                                        }
                                    }
                                    else
                                    {
                                        errores.Add("Tanto agencia como clasificación deben estar presentes.");
                                    }

                                }
                                reader.Close();
                                db.SaveChanges();
                                TempData["Errores"] = errores.ToList();
                                TempData["Count"] = successCount;
                                return RedirectToAction("Success");
                            }
                        }
                        catch (Exception e)
                        {
                            if (e is DbEntityValidationException)
                            {
                                DbEntityValidationException dbEx = (DbEntityValidationException)e;
                                foreach (var validationErrors in dbEx.EntityValidationErrors)
                                {
                                    foreach (var validationError in validationErrors.ValidationErrors)
                                    {
                                        errores.Add("Property: " + validationError.PropertyName + " Error: " + validationError.ErrorMessage);
                                    }
                                }
                            }
                            errores.Add(e.ToString());
                            TempData["Errores"] = errores.ToList();
                            return RedirectToAction("Error");

                        }
                    }
                }
                else
                {
                    errores.Add("Debe subir un archivo");
                    TempData["Errores"] = errores.ToList();
                    return RedirectToAction("Error");
                }
            }
            catch (Exception e)
            {
                errores.Add(e.ToString());
                TempData["Errores"] = errores.ToList();
                return RedirectToAction("Error");
            }
            return RedirectToAction("Error");
        }