public ActionResult Load(HttpPostedFileBase idUploadFile, ImportO2SModel model)
        {
            var path = string.Empty;
            try
            {
                ImportHelper pImportHelper = new ImportHelper();

                //If user has already customers, set IsUpdateMode to true by default
                if (CustomerProspectBL.GetCustomerByIdUserCreated(SessionManager.GetUserSession().idUser).Count() > 0)
                {
                    //model.IsUpdateMode = true;
                    model.ImportMode = (int)ImportO2SModel.ModeOfImport.Update;
                }

                //  if (ModelState.IsValid)
                {
                    // Verify that the user selected a file
                    if (idUploadFile != null && idUploadFile.ContentLength > 0)
                    {

                        // extract only the fielname
                        var fileName = string.Format("{0}-{1}", DateTime.Now.ToString("ddMMyyyy"), Path.GetFileName(idUploadFile.FileName));

                        path = Path.Combine(Server.MapPath("~/uploads"), fileName);

                        if (!Directory.Exists(Server.MapPath("~/uploads")))
                            Directory.CreateDirectory(Server.MapPath("~/uploads"));


                        // ImportHelper pImportHelper = new ImportHelper(); 
                        //pImportHelper.TestGetByName();
                        //  pImportHelper.Load(path);

                        //2014-07-29 : Check file extension
                        if (Path.GetExtension(path).Equals(".xlsx") || Path.GetExtension(path).Equals(".xls"))
                        {
                            idUploadFile.SaveAs(path);
                            // ViewData["FileFullPath"] = path;

                            model.SheetNames = pImportHelper.GetSheetNames(path);
                            if (model.SheetNames.Count == 1)
                            {
                                model.SelectedSheetName = model.SheetNames[0].Value;
                                model.ColumnNames = pImportHelper.GetUsableColumnNames(path, model.SelectedSheetName);
                            }
                            model.FullFilePath = path;


                            //prendre la liste des conseillers principaux
                            model.ListAdvisers = pImportHelper.GetListConseillerPrincicpal(model.FullFilePath, model.SelectedSheetName);

                            //prendre et charger la liste de tous ces **** de client
                            if (SessionManager.GetUserSession().CanViewAdvisersList())
                            {
                                bool filterAdvisersByUserFirm = (SessionManager.GetUserSession().IsAdministrativeAssistant()) ? true : false;
                                var lstAdvisers = Business.Configuration.FirmInstitutionAdviserBL.GetAdvisersByIdFirmParent(SessionManager.GetFirmInstitutionSession(), SessionManager.GetUserSession(), filterAdvisersByUserFirm, false)
                                                       .GroupBy(a => a.idUser)
                                                       .Select(ad => ad.First())
                                                       .OrderBy(a => a.User.UserName)
                                                       .ToList<FirmInstitutionAdviser>();


                                //List<FirmInstitutionAdviser> lstAdvisers = FirmInstitutionAdviserBL.GetAdvisers(SessionManager.GetFirmInstitutionSession(), false);
                                model.ListAdvisersFromDatabase = new List<SelectListItem>();

                                //add vide
                                model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = "", Value = "" });

                                foreach (var adviser in lstAdvisers)
                                {
                                    model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = string.Format("{0}, {1}, {2}", adviser.User.UserName, adviser.User.UserFirstName, adviser.User.UserEmail), Value = adviser.User.idUser.ToString() });
                                }
                            }
                            else
                            {
                                bool isEmpty = CustomerProspectBL.IsProspectForCGPEmpty(SessionManager.GetUserSession().idUser, model.IsCustomer);

                                model.InitilizationModeChecked = isEmpty;//utilisé ??
                                model.UpdateModeChecked = !isEmpty; //utilisé ??
                                if (isEmpty)
                                    model.ImportMode = (int)ImportO2SModel.ModeOfImport.Initialisation;
                                else
                                    model.ImportMode = (int)ImportO2SModel.ModeOfImport.Update;
                            }
                        }
                        else
                        {
                            //2014-07-29 : Error File not supported
                            ViewBag.Error = LanguageData.GetContent("seul_excel_autorise");
                        }

                        return View("ImportO2Harvest", model);
                    }
                    else
                    {
                        ViewBag.Error = LanguageData.GetContent("verifier_fichier_a_uploader");
                        return View("ImportO2Harvest", model);
                    }


                }
                // ViewBag.Error = "Veuillez vérifier les champs obligatoires.";

            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;
                ViewBag.Error = string.Format("{0} : {1}", LanguageData.GetContent("erreur_import"), ex.Message);
            }

            return View("ImportO2Harvest");
        }
        public ActionResult LoadXlsCsv(HttpPostedFileBase idUploadFile, ImportO2SModel model)
        {
            var path = string.Empty;
            try
            {
                //If user has already customers, set IsUpdateMode to true by default
                if (CustomerProspectBL.GetCustomerByIdUserCreated(SessionManager.GetUserSession().idUser).Count() > 0)
                {
                    //model.IsUpdateMode = true;
                    model.ImportMode = (int)ImportO2SModel.ModeOfImport.Update;
                }

                //  if (ModelState.IsValid)
                {
                    // Verify that the user selected a file
                    if (idUploadFile != null && idUploadFile.ContentLength > 0)
                    {

                        // extract only the fielname
                        var fileName = string.Format("{0}-{1}", DateTime.Now.ToString("ddMMyyyy"), Path.GetFileName(idUploadFile.FileName));

                        path = Path.Combine(Server.MapPath("~/uploads"), fileName);

                        if (!Directory.Exists(Server.MapPath("~/uploads")))
                            Directory.CreateDirectory(Server.MapPath("~/uploads"));


                        if (Path.GetExtension(path).Equals(".xlsx")
                            || Path.GetExtension(path).Equals(".xls"))
                        {
                            idUploadFile.SaveAs(path);

                            ImportHelper pImportHelper = new ImportHelper();
                            //  pImportHelper.Load(path);
                            model.SheetNames = new ImportHelper().GetSheetNames(path);
                            if (model.SheetNames.Count == 1)
                            {
                                model.SelectedSheetName = model.SheetNames[0].Value;
                                model.ColumnNames = new ImportHelper().GetUsableColumnNames(path, model.SelectedSheetName);
                                model.Source = ImportO2SModel.FileSource.Excel;
                            }
                        }
                        else if (Path.GetExtension(path).ToLower() == ".csv")
                        {
                            idUploadFile.SaveAs(path);
                            model.Source = ImportO2SModel.FileSource.CSV;
                            //if (model.Delimiter == "DEFAULT_DELIMITER")
                            //    model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(path, CSV.DEFAULT_DELIMITER);
                            //else
                            //    model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(path, CSV.SEMI_COLON_DELIMITER);

                        }
                        else
                        {
                            //2014-07-29 : Error File not supported
                            ViewBag.Error = LanguageData.GetContent("seul_excel_csv_autorise");
                        }

                        model.FullFilePath = path;
                        return View("XlsCsv", model);
                    }
                    else
                    {
                        ViewBag.Error = LanguageData.GetContent("verifier_fichier_a_uploader");
                        return View("XlsCsv", model);
                    }

                }
                // ViewBag.Error = "Veuillez vérifier les champs obligatoires.";

            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;
                ViewBag.Error = string.Format("{0} : {1}", LanguageData.GetContent("erreur_import"), ex.Message);
            }

            return View("XlsCsv");
        }
        public ActionResult ProcessManymoreXlsCsv(ImportO2SModel model)
        {
            model.Source = ImportO2SModel.FileSource.CSV;
            //  char delimiter = CSV.SEMI_COLON_DELIMITER;

            ImportHelper pImportHelper = new ImportHelper();

            try
            {
                if (ModelState.IsValid && !string.IsNullOrEmpty(model.FullFilePath))
                {

                    int total = 0, vita = 0;
                    IList<ImportErrorModel> errorsList = new List<ImportErrorModel>();

                    vita = pImportHelper.ImportProcessing(model, out total, out errorsList, null, true, /*delimiter*/model.Separator);

                    //if (model.IsUpdateMode)
                    //{

                    //    //   ImportHelper pImportHelper = new ImportHelper();
                    //    vita = pImportHelper.ImportManyMore(model.FullFilePath.ToString(), model, true, out total, delimiter);
                    //}
                    //else
                    //{

                    //    //TODO:delete test
                    //    if (!CustomerProspectBL.DeleteAllProspectForCGP(SessionManager.GetUserSession().idUser))
                    //        throw new Exception("DeleteAllProspectForCGP");


                    //    // pImportHelper = new ImportHelper();
                    //    vita = pImportHelper.ImportManyMore(model.FullFilePath.ToString(), model, false, out total, delimiter);

                    //}
                    ViewBag.Message = string.Format("{0} {1} / {2}", LanguageData.GetContent("nb_ligne_importées"), vita, total);

                    if (errorsList.Count > 0)
                    {
                        ViewBag.Errors = errorsList;
                    }

                    model.CanImportNewFile = true;

                    return View("XlsCsv", model);
                }
                else ViewBag.Error = LanguageData.GetContent("verifier_champs_obligatoires");
            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;

                ViewBag.Error = LanguageData.GetContent("erreur_import");
            }
            if (model.Delimiter == "DEFAULT_DELIMITER")
                model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(model.FullFilePath, CSV.DEFAULT_DELIMITER);
            else
                model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(model.FullFilePath, CSV.SEMI_COLON_DELIMITER);

            return View("XlsCsv", model);

        }
        public ActionResult LoadCSV(HttpPostedFileBase idUploadFile, ImportO2SModel model)
        {
            var path = string.Empty;
            try
            {
                //If user has already customers, set IsUpdateMode to true by default
                if (CustomerProspectBL.GetCustomerByIdUserCreated(SessionManager.GetUserSession().idUser).Count() > 0)
                {
                    //model.IsUpdateMode = true;
                    model.ImportMode = (int)ImportO2SModel.ModeOfImport.Update;
                }

                if (idUploadFile != null && idUploadFile.ContentLength > 0)
                {

                    // extract only the fielname
                    var fileName = string.Format("{0}-{1}", DateTime.Now.ToString("ddMMyyyy"), Path.GetFileName(idUploadFile.FileName));

                    path = Path.Combine(Server.MapPath("~/uploads"), fileName);

                    if (!Directory.Exists(Server.MapPath("~/uploads")))
                        Directory.CreateDirectory(Server.MapPath("~/uploads"));

                    //Check extension
                    if (Path.GetExtension(path).ToLower() == ".csv")
                    {

                        idUploadFile.SaveAs(path);

                        model.FullFilePath = path;

                        ImportHelper helper = new ImportHelper();
                        if (model.Delimiter == "DEFAULT_DELIMITER")
                            model.ColumnNames = helper.GetCSVUsableColumnNames(path, CSV.DEFAULT_DELIMITER);
                        else
                            model.ColumnNames = helper.GetCSVUsableColumnNames(path, CSV.SEMI_COLON_DELIMITER);

                        //TODO: REMOVE
                        //prendre la liste des conseillers principaux
                        //model.ListAdvisers = helper.GetListConseillerPrincicpal(model.FullFilePath,null,true, model.Separator);

                        ////prendre et charger la liste de tous ces **** de client
                        //if (SessionManager.GetUserSession().IsAdmin())
                        //{
                        //    var lstAdvisers = Business.Configuration.FirmInstitutionAdviserBL.GetAdvisersByIdParent(SessionManager.GetFirmInstitutionSession(), false)
                        //                           .GroupBy(a => a.idUser)
                        //                           .Select(ad => ad.First())
                        //                           .OrderBy(a => a.User.UserName)
                        //                           .ToList<FirmInstitutionAdviser>();


                        //    //List<FirmInstitutionAdviser> lstAdvisers = FirmInstitutionAdviserBL.GetAdvisers(SessionManager.GetFirmInstitutionSession(), false);
                        //    model.ListAdvisersFromDatabase = new List<SelectListItem>();

                        //    //add vide
                        //    model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = "", Value = "" });

                        //    foreach (var adviser in lstAdvisers)
                        //    {
                        //        model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = string.Format("{0}, {1}, {2}", adviser.User.UserName, adviser.User.UserFirstName, adviser.User.UserEmail), Value = adviser.User.idUser.ToString() });
                        //    }
                        //}


                        //radio button
                    }
                    else
                    {
                        //2014-07-29 : Error File not supported
                        ViewBag.Error = LanguageData.GetContent("seul_csv_autorise");
                    }

                    return View("ImportManyMore", model);
                }
                else
                {
                    ViewBag.Error = LanguageData.GetContent("verifier_fichier_a_uploader");
                    return View("ImportManyMore", model);
                }
            }
            catch (ArgumentException ex)
            {
                Log.AppendException(ex);
                if (ex.Message.Contains("Conseiller principal"))
                    ViewBag.Error = LanguageData.GetContent("verifier_presence_colonne");
                else
                    ViewBag.Error = ex.Message;

            }
            catch (Exception ex)
            {
                Log.AppendException(ex);
                ViewBag.Error = LanguageData.GetContent("erreur_import_contacter_admin");
            }

            return View("ImportManyMore");
        }
        public ActionResult ProcessManymore(ImportO2SModel model)
        {
            //char delimiter = CSV.SEMI_COLON_DELIMITER;
            try
            {
                int mode = Convert.ToInt32(Request["ImportMode"]);
                model.ImportMode = mode;
                ImportHelper helper = new ImportHelper();

                //TODO:REMOVE
                //correspondance des advisers
                //Dictionary<string, Guid> dicAdvisers = new Dictionary<string, Guid>();

                //if (SessionManager.GetUserSession().IsAdmin())
                //{
                //    //prendre et charger la liste de tous ces **** de client
                //    List<FirmInstitutionAdviser> lstAdvisers = FirmInstitutionAdviserBL.GetAdvisers(SessionManager.GetFirmInstitutionSession(), false);
                //    model.ListAdvisersFromDatabase = new List<SelectListItem>();
                //    foreach (var adviser in lstAdvisers)
                //    {
                //        model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = string.Format("{0}, {1}, {2}", adviser.User.UserName, adviser.User.UserFirstName, adviser.User.UserEmail), Value = adviser.User.idUser.ToString() });
                //    }


                //    model.ListAdvisers = helper.GetListConseillerPrincicpal(model.FullFilePath,null,true, model.Separator);

                //    //TODO : Otran ts mety ilay samy dropdown a

                //    //prendre la correspondance des advisers selon l'admin
                //    foreach (var importAdvisers in model.ListAdvisers)
                //    {
                //        string adviserKey = "Advisers_" + importAdvisers.Value.Replace(" ", "_");
                //        string adviserFromDatabaseKey = "AdvisersFromDatabase_" + importAdvisers.Value.Replace(" ", "_");

                //        if (!string.IsNullOrEmpty(Request.Params[adviserKey].ToString()) && !string.IsNullOrEmpty(Request.Params[adviserFromDatabaseKey].ToString()))
                //        {
                //            dicAdvisers.Add(/*importAdvisers.Value*/Request.Params[adviserKey], new Guid(Request.Params[adviserFromDatabaseKey]));
                //        }
                //    }
                //}

                if (ModelState.IsValid && !string.IsNullOrEmpty(model.FullFilePath))
                {

                    int total = 0, vita = 0;
                    IList<ImportErrorModel> errorsList = new List<ImportErrorModel>();

                    //TODO:REMOVE DIC
                    vita = helper.ImportProcessing(model, out total, out errorsList, null, true, /*delimiter*/model.Separator/*, dicAdvisers*/);

                    ViewBag.Message = string.Format("{0} {1} / {2}", LanguageData.GetContent("nb_ligne_importées"), vita, total);

                    if (errorsList.Count > 0)
                    {
                        ViewBag.Errors = errorsList;
                    }

                    model.CanImportNewFile = true;

                    return View("ImportManyMore", model);
                }
                else
                {
                    var errors = ModelState.Values.SelectMany(v => v.Errors);
                    ViewBag.Error = LanguageData.GetContent("verifier_champs_obligatoires");
                }
            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;

                ViewBag.Error = string.Format("{0} : {1}", LanguageData.GetContent("erreur_import"), ex.Message);
            }
            if (model.Delimiter == "DEFAULT_DELIMITER")
                model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(model.FullFilePath, CSV.DEFAULT_DELIMITER);
            else
                model.ColumnNames = new ImportHelper().GetCSVUsableColumnNames(model.FullFilePath, CSV.SEMI_COLON_DELIMITER);

            return View("ImportManyMore", model);

        }
        public ActionResult ProcessImportExcel(ImportO2SModel model)
        {
            try
            {
                if (ModelState.IsValid && !string.IsNullOrEmpty(model.FullFilePath))
                {
                    int total = 0, vita = 0;
                    int mode = Convert.ToInt32(Request["ImportMode"]);
                    model.ImportMode = mode;
                    IList<ImportErrorModel> errorsList = new List<ImportErrorModel>();

                    ImportHelper pImportHelper = new ImportHelper();
                    vita = pImportHelper.ImportProcessing(model, out  total, out errorsList, model.SelectedSheetName);

                    ViewBag.Message = string.Format("{0} {1} / {2}", LanguageData.GetContent("nb_ligne_importées"), vita, total);

                    if (errorsList.Count > 0)
                    {
                        ViewBag.Errors = errorsList;
                    }

                    model.CanImportNewFile = true;

                    return View("XlsCsv", model);
                }
                else ViewBag.Error = LanguageData.GetContent("verifier_champs_obligatoires");
            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;

                ViewBag.Error = string.Format("{0} : {1}", LanguageData.GetContent("erreur_import"), ex.Message);
            }

            model.ColumnNames = new ImportHelper().GetUsableColumnNames(model.FullFilePath, model.SelectedSheetName);
            model.SheetNames = new ImportHelper().GetSheetNames(model.FullFilePath);
            model.IsSheetNameSelection = true;
            return View("XlsCsv", model);

        }
        public ActionResult ProcessImportO2Harvest(ImportO2SModel model)
        {
            try
            {
                ImportHelper pImportHelper = new ImportHelper();
               
                //correspondance des advisers
                Dictionary<string, Guid> dicAdvisers = new Dictionary<string, Guid>();

                if (SessionManager.GetUserSession().IsAdmin())
                {
                    //prendre et charger la liste de tous ces **** de client
                    List<FirmInstitutionAdviser> lstAdvisers = FirmInstitutionAdviserBL.GetAdvisers(!model.idFirmInstitution.HasValue ? SessionManager.GetFirmInstitutionSession() : FirmInstitutionBL.GetFirmInstitutionByIdFirmInstitution(model.idFirmInstitution.Value), false);
                    model.ListAdvisersFromDatabase = new List<SelectListItem>();
                    foreach (var adviser in lstAdvisers)
                    {
                        model.ListAdvisersFromDatabase.Add(new SelectListItem() { Text = string.Format("{0}, {1}, {2}", adviser.User.UserName, adviser.User.UserFirstName, adviser.User.UserEmail), Value = adviser.User.idUser.ToString() });
                    }


                    model.ListAdvisers = pImportHelper.GetListConseillerPrincicpal(model.FullFilePath, model.SelectedSheetName);

                    //TODO : Otran ts mety ilay samy dropdown a

                    //prendre la correspondance des advisers selon l'admin
                    foreach (var importAdvisers in model.ListAdvisers)
                    {
                        string adviserKey = "Advisers_" + importAdvisers.Value.Replace(" ", "_");
                        string adviserFromDatabaseKey = "AdvisersFromDatabase_" + importAdvisers.Value.Replace(" ", "_");

                        if (!string.IsNullOrEmpty(Request.Params[adviserKey].ToString()) && !string.IsNullOrEmpty(Request.Params[adviserFromDatabaseKey].ToString()))
                        {
                            dicAdvisers.Add(/*importAdvisers.Value*/Request.Params[adviserKey], new Guid(Request.Params[adviserFromDatabaseKey]));
                        }
                    }
                }

                if (ModelState.IsValid && !string.IsNullOrEmpty(model.FullFilePath))
                {
                    int mode = Convert.ToInt32(Request["ImportMode"]);
                    model.ImportMode = mode;
                    int total = 0, vita = 0;
                    IList<ImportErrorModel> errorsList = new List<ImportErrorModel>();

                    //TODO:add DIC
                    vita = pImportHelper.ImportProcessing(model, out  total, out errorsList, model.SelectedSheetName, false, CSV.DEFAULT_DELIMITER, dicAdvisers);

                    ViewBag.Message = string.Format("{0} {1} / {2}", LanguageData.GetContent("nb_ligne_importées"), vita, total);

                    if (errorsList.Count > 0)
                    {
                        ViewBag.Errors = errorsList;
                    }

                    model.CanImportNewFile = true;

                    return View("ImportO2Harvest", model);
                }
                else ViewBag.Error = LanguageData.GetContent("verifier_champs_obligatoires");
            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;

                ViewBag.Error = string.Format("{0} : {1}", LanguageData.GetContent("erreur_import"), ex.Message);
            }

            model.ColumnNames = new ImportHelper().GetUsableColumnNames(model.FullFilePath, model.SelectedSheetName);
            model.SheetNames = new ImportHelper().GetSheetNames(model.FullFilePath);
            model.IsSheetNameSelection = true;
            return View("ImportO2Harvest", model);

        }
        public ActionResult HandleColumnselectionXlsCsv(ImportO2SModel model)
        {
            try
            {
                ImportHelper helper = new ImportHelper();
                int mode = Convert.ToInt32(Request["ImportMode"]);
                model.ImportMode = mode;
                model.IsSheetNameSelection = true;
                model.ColumnNames = helper.GetUsableColumnNames(model.FullFilePath, model.SelectedSheetName);
                return View("XlsCsv", model);
            }
            catch (Exception ex)
            {
                Log.AppendException(ex); ;

                ViewBag.Error = LanguageData.GetContent("erreur_obtention_nom_colonne");
            }
            return View("XlsCsv");
        }
        public ActionResult HandleSheetSelection(ImportO2SModel model)
        {
            try
            {
                int mode = Convert.ToInt32(Request["ImportMode"]);
                model.ImportMode = mode;
                ImportHelper helper = new ImportHelper();
                DataTable dt = helper.ReadClientDataTableXLS(model.FullFilePath, model.SelectedSheetName, 20);
                model.Datashot = dt;

                model.SheetNames = helper.GetSheetNames(model.FullFilePath);
                return View("ImportO2Harvest", model);
            }
            catch (Exception ex)
            {
                Log.AppendException(ex);
                ViewBag.Error = LanguageData.GetContent("erreur_selection_feuille");
            }
            return View("ImportO2Harvest");
        }