none
Excel interop : preventing the application from opening read-only files RRS feed

  • Question

  • Hello,

    I'm making an app that modify macros on several EXCEL files within a given directory and my issue is the following :

    when i choose a directory that is "Read Only", my app open the files, modify the macros and save it into mydocs.

    But I don't want it to do that. It was supposed to simply say "sorry, you do not have the rigths to write in this directory".

    Here are parts of my code :

    the opening file part :

            public ExcelInterop.Excel.Workbook OuvertureFichier(ExcelInterop.Excel.Application pApplication, string pChemin, string pPassword)
            {
                try
                {
                    //dm - on crée et on retourne un workbook.
                    return pApplication.Workbooks.Open(
                        pChemin, // chemin du fichier excel.
                        false,  //update link
                        false,  //readonly
                        Type.Missing,   //format
                        Type.Missing,   //read password
                        pPassword,    //write password
                        true,           //ignorereadonly recommanded
                        Type.Missing,   //origin
                        Type.Missing,   //delimiter
                        true,           //editable
                        false,          //notify
                        Type.Missing,   //converter
                        false,          //addToMru
                        true,           //local
                        Type.Missing);  //corruptload
                }
                catch(Exception e)
                { throw(e); }
            }

    the checking of the rights on the directory :

            public bool ValiditeRepetoire(string pChemin)
            {
                FileSystemRights lDroitMini= FileSystemRights.Read|FileSystemRights.ListDirectory;
                //dm - recuperation du compte utilisateur d'un point de vue sécurité.
                System.Security.Principal.WindowsIdentity lUser = System.Security.Principal.WindowsIdentity.GetCurrent();
    
                //dm - on va tester les droits de l'utilisateur et des groupes auxquels il appartient.
                //dm - si au moins l'une de ces entités n'a pas les droits, alors l'utilisateur n'a pas les droits.
    
                //on part du prédicat qu'il a les droits
                bool lAccord = true;
    
                try
                {
                    //recuperation des droits.
                    FileSystemSecurity lAccessControlList = File.GetAccessControl(pChemin);
                    AuthorizationRuleCollection lRules = lAccessControlList.GetAccessRules(true, true, typeof(SecurityIdentifier));
    
                    //dm - pour chaque droit.
                    foreach(FileSystemAccessRule pRule in lRules)
                    {
                        if (pRule.IdentityReference.Value.Equals(lUser.User.Value, StringComparison.CurrentCultureIgnoreCase))
                        {                        
                            if (pRule.AccessControlType == AccessControlType.Deny && pRule.FileSystemRights.HasFlag(lDroitMini)) { return false; } //permissions demandées refusées
                        }
                    }
    
                    // dm - examen des droits des groupes.
                    //dm - our chaque groupe.
                    foreach(IdentityReference pGroupe in lUser.Groups)
                    {
                        //dm - pour chaque règle.
                        foreach(FileSystemAccessRule pGRule in lRules)
                        {
                            //dm - si le groupe correspond à la règle qu'on vérifie.
                            if(pGroupe.Equals(pGRule.IdentityReference))
                            {
                                //dm - si la règle en question est de type refus.
                                if (pGRule.AccessControlType == AccessControlType.Deny && pGRule.FileSystemRights.HasFlag(lDroitMini)) { return false; } //permissions demandées refusées
                            }
                        }
                    }
                    //dm - si on atteint ce point, aucune règle n'interdit à l'utilisateur d'écrire. il a donc les droits.
                    return lAccord;
                }
                catch
                {
                    //dm - en cas d'erreur, on part du principe que l'utilisateur n'a pas les droits.
                    return false;
                }            
            }

    Can somebody help me?

    thanks

    Thursday, May 21, 2015 9:30 AM

Answers

  • Well, I solved the problem by myslef... with the kind of solution i tend to dislike :

    In the try catch of my Rights Cheking method, i added the following code :

    //dm - deuxième vérification, cette fois par l'erreur, pour voir si le dossier est en lecture seule.
                    string lTestEcriture = Path.Combine(pChemin, "TestEcriture.txt");
                    //dm - normalement, si on a pas les droits en écriture. cela doit lever une erreur.
                    System.IO.File.WriteAllText(lTestEcriture, "si ce texte s'est ecrit. c'est qu'on à les droits en écriture.");

    this code will throw an exception if i do not have the rights to write in the given directory. so my try catch will catch it and the app will work as intended in the first place.



    • Edited by Thiamael84 Thursday, May 21, 2015 2:33 PM
    • Marked as answer by Thiamael84 Thursday, May 21, 2015 2:36 PM
    Thursday, May 21, 2015 2:31 PM