/// <summary>
/// Initializes a new instance of the <see cref="FileSystem" /> class.
/// </summary>
/// <param name="root">The absolute path to the root directory of this file system (..../Pie/ or .../Pie).</param>
public FileSystem(String root)
{
// Append separator to root, if it hasn't got it
_fileSystemRoot = root + (root.EndsWith(PathSeparator) ? String.Empty : PathSeparator);
DirectoryInfo dirInfo = new DirectoryInfo(_fileSystemRoot);
// Create directory if it doesn't exist
if (!Directory.Exists(_fileSystemRoot))
{
Directory.CreateDirectory(_fileSystemRoot);
}
// Make sure the directory has the right permissions
try
{
// Attempt to get a list of security permissions from the folder.
// This will raise an exception if the path is read only or do not have access to view the permissions.
System.Security.AccessControl.DirectorySecurity ds = Directory.GetAccessControl(_fileSystemRoot);
}
catch (UnauthorizedAccessException)
{
var security = new DirectorySecurity();
var windowsIdentity = WindowsIdentity.GetCurrent();
if (windowsIdentity != null)
{
var id = windowsIdentity.User;
var rule = new FileSystemAccessRule(id, FileSystemRights.FullControl, AccessControlType.Allow);
security.AddAccessRule(rule);
dirInfo.SetAccessControl(security);
}
}
}
/// <summary>
/// Make a folder if doesn't exist
/// </summary>
/// <param name="folderPath"></param>
/// <returns></returns>
public static bool MakeFolder(string folderPath)
{
if (!Directory.Exists(folderPath))
{
try
{
DirectorySecurity securityRules = new DirectorySecurity();
securityRules.AddAccessRule(new FileSystemAccessRule("Users", FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.NoPropagateInherit,
AccessControlType.Allow));
Directory.CreateDirectory(folderPath, securityRules);
File.SetAttributes(folderPath, FileAttributes.Normal);
}
catch (Exception ex)
{
Console.WriteLine("Exception trying to create folder: " + folderPath);
if (ex.InnerException != null)
Console.WriteLine(ex.InnerException.Message);
else
Console.WriteLine(ex.Message);
return false;
}
}
return true;
}
static Locations()
{
if (WindowsUtils.IsWindowsNT)
{
_secureSharedAcl = new DirectorySecurity();
_secureSharedAcl.SetOwner(new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null));
_secureSharedAcl.SetAccessRuleProtection(isProtected: true, preserveInheritance: false);
_secureSharedAcl.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier("S-1-1-0" /*Everyone*/), FileSystemRights.ReadAndExecute, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
_secureSharedAcl.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.ReadAndExecute, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
_secureSharedAcl.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
_secureSharedAcl.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.LocalSystemSid, null), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
}
}
static void SetAccessRule(string directory)
{
System.Security.AccessControl.DirectorySecurity sec = System.IO.Directory.GetAccessControl(directory);
FileSystemAccessRule accRule = new FileSystemAccessRule(Environment.UserDomainName + "\\" + Environment.UserName, FileSystemRights.FullControl, AccessControlType.Allow);
sec.AddAccessRule(accRule);
}
public static void AddDirectorySecurity(string strPath, string Account, System.Security.AccessControl.FileSystemRights Rights, System.Security.AccessControl.AccessControlType ControlType)
{
System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(strPath);
System.Security.AccessControl.DirectorySecurity accessControl = directoryInfo.GetAccessControl();
accessControl.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule(Account, Rights, ControlType));
directoryInfo.SetAccessControl(accessControl);
}
/// <summary>
/// Set required permissions to the Phalanger install folder. To enable phalanger ASP.NET app i.e. to generate/modify dynamic wrappers.
/// </summary>
/// <param name="folder">Phalanger install folder.</param>
private static void SetEveryonePermission(string folder)
{
var everyonesid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.WorldSid, null);
FileSystemAccessRule everyOne = new FileSystemAccessRule(everyonesid, FileSystemRights.FullControl | FileSystemRights.Write | FileSystemRights.Read, AccessControlType.Allow);
DirectorySecurity dirSecurity = new DirectorySecurity(folder, AccessControlSections.Group);
dirSecurity.AddAccessRule(everyOne);
Directory.SetAccessControl(folder, dirSecurity);
}
protected override void ExecuteOnDir(DirectoryInfo dir)
{
DirectorySecurity dirSec = new DirectorySecurity(dir.FullName, AccessControlSections.Access);
Log(Level.Info, Resources.AddAccessRuleAdding, Rights, NTAccount, dir.FullName);
FileSystemAccessRule newRule = new FileSystemAccessRule(new NTAccount(NTAccount), Rights, InheritanceFlags, PropagationFlags, AccessControlType);
dirSec.AddAccessRule(newRule);
dir.SetAccessControl(dirSec);
}
/// <summary>
/// 给文件夹添加完全控制权限
/// </summary>
/// <param name="directoryPath"></param>
public static void AddTopPermissionToDirectory(string directoryPath)
{
if (string.IsNullOrEmpty(directoryPath))
{
return;
}
//给文件所在目录添加"Everyone,Users"用户组的完全控制权限
DirectoryInfo directoryInfo = new DirectoryInfo(Path.GetDirectoryName(directoryPath));
if (directoryInfo == null)
{
return;
}
System.Security.AccessControl.DirectorySecurity dirSecurity = directoryInfo.GetAccessControl();
dirSecurity.AddAccessRule(new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, AccessControlType.Allow));
dirSecurity.AddAccessRule(new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow));
directoryInfo.SetAccessControl(dirSecurity);
}
/// <summary>
/// 作用：文件夹授权
/// 作者：杨洋AY
/// 添加时间：2016-6-19
/// </summary>
/// <param name="DirectoryPath">需要被授权的文件夹，默认是Everyone</param>
public virtual void AccessDirectoryRights(string DirectoryPath, string DirectoryAuth = "Everyone")
{
DirectoryInfo di = Directory.CreateDirectory(DirectoryPath);
//赋予文件夹权限
System.Security.AccessControl.DirectorySecurity dirSecurity = di.GetAccessControl();
dirSecurity.AddAccessRule(new FileSystemAccessRule(DirectoryAuth, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
di.SetAccessControl(dirSecurity);
}
/// <summary>
/// Add an access rule to a folder
/// </summary>
///
/// <param name="Path">Folder path</param>
/// <param name="User">UNC path to user profile ex. Environment.UserDomainName + "\\" + Environment.UserName</param>
/// <param name="Rights">Desired file system rights</param>
/// <param name="Access">Desired level of access</param>
public static void AddAccessRule(string Path, string User, FileSystemRights Rights, AccessControlType Access)
{
// Get a DirectorySecurity object that represents the current security settings
System.Security.AccessControl.DirectorySecurity sec = System.IO.Directory.GetAccessControl(Path);
// Add the FileSystemAccessRule to the security settings
FileSystemAccessRule accRule = new FileSystemAccessRule(User, Rights, Access);
sec.AddAccessRule(accRule);
}
public Form1()
{
InitializeComponent();
orgHieght = this.Height;
bigHeight = this.orgHieght + this.richTextBox1.Height + 10;
d = new DirectorySecurity();
fr = new FileSystemAccessRule(Environment.UserName, FileSystemRights.FullControl, AccessControlType.Allow);
d.AddAccessRule(fr);
mainDir = Directory.CreateDirectory("c:/JTRacker", d);
}
static void Main(string[] args)
{
DirectorySecurity ds = new DirectorySecurity();
ds.AddAccessRule(new FileSystemAccessRule("Guest", FileSystemRights.Read, AccessControlType.Allow));
string newFolder = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Guest");
Directory.CreateDirectory(newFolder, ds);
string newFile = System.IO.Path.Combine(newFolder, "Data.dat");
File.Create(newFile);
}
internal static void CreateDirectory(string path, IsolatedStorageScope scope)
{
if (Directory.Exists(path))
return;
DirectoryInfo info = Directory.CreateDirectory(path);
if (IsMachine(scope) && RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// Need to emulate COMIsolatedStorage::CreateDirectoryWithDacl(), which gives the following rights:
//
// World / Everyone (S-1-1-0 / SECURITY_WORLD_RID) -> (FILE_GENERIC_WRITE | FILE_GENERIC_READ) & (~WRITE_DAC)
// Creator Owner (S-1-3-0 / SECURITY_CREATOR_OWNER_RID) -> FILE_ALL_ACCESS
// Local Admins (S-1-5-32 / SECURITY_BUILTIN_DOMAIN_RID & DOMAIN_ALIAS_RID_ADMINS) -> FILE_ALL_ACCESS
//
// When looking at rights through the GUI it looks like this:
//
// "Everyone" -> Read, Write
// "Administrators" -> Full control
// "CREATOR OWNER" -> Full control
//
// With rights applying to "This folder, subfolders, and files". No inheritance from the parent folder.
//
// Note that trying to reset the rules for CREATOR OWNER leaves the current directory with the actual creator's SID.
// (But applies CREATOR OWNER as expected for items and subdirectories.) Setting up front when creating the directory
// doesn't exhibit this behavior, but as we can't currently do that we'll take the rough equivalent for now.
DirectorySecurity security = new DirectorySecurity();
// Don't inherit the existing rules
security.SetAccessRuleProtection(isProtected: true, preserveInheritance: false);
security.AddAccessRule(new FileSystemAccessRule(
identity: new SecurityIdentifier(WellKnownSidType.WorldSid, null),
fileSystemRights: FileSystemRights.Read | FileSystemRights.Write,
inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
propagationFlags: PropagationFlags.None,
type: AccessControlType.Allow));
security.AddAccessRule(new FileSystemAccessRule(
identity: new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null),
fileSystemRights: FileSystemRights.FullControl,
inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
propagationFlags: PropagationFlags.None,
type: AccessControlType.Allow));
security.AddAccessRule(new FileSystemAccessRule(
identity: new SecurityIdentifier(WellKnownSidType.CreatorOwnerSid, null),
fileSystemRights: FileSystemRights.FullControl,
inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
propagationFlags: PropagationFlags.None,
type: AccessControlType.Allow));
info.SetAccessControl(security);
}
}
static void Main(string[] args)
{
DirectorySecurity ds = new DirectorySecurity();
ds.AddAccessRule(new FileSystemAccessRule("Rafa&Pri", FileSystemRights.Read, AccessControlType.Allow));
string newFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Rafa&Pri");
Directory.CreateDirectory(newFolder, ds);
FileSecurity fs = new FileSecurity();
fs.AddAccessRule(new FileSystemAccessRule("Rafa&Pri", FileSystemRights.FullControl, AccessControlType.Allow));
string newFile = Path.Combine(newFolder, "Data.dat");
File.Create(newFile, 100, FileOptions.None, fs);
}
public void BreadcrumbsCreationDoesNotFailWhenAccessDenied()
{
var userName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
var directory = new DirectoryInfo(TempFolderPath);
var security = new DirectorySecurity();
security.AddAccessRule(new FileSystemAccessRule(userName, FileSystemRights.Write, AccessControlType.Deny));
directory.SetAccessControl(security);
var breadcrumbs = new Servicing.Breadcrumbs(TempFolderPath);
breadcrumbs.CreateBreadcrumb("Test", new NuGet.SemanticVersion("1.0.0"));
Assert.Empty(Directory.GetFiles(TempFolderPath));
}
static void Main()
{
const string dir = @"C:\test";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
System.Security.AccessControl.DirectorySecurity ds = Directory.GetAccessControl(dir);
ds.AddAccessRule(new FileSystemAccessRule("Guest", FileSystemRights.Read, AccessControlType.Allow));
Directory.SetAccessControl(dir, ds);
Console.WriteLine(ds.GetSecurityDescriptorSddlForm(AccessControlSections.All));
}
public static bool AllowFolderAccess(string path, FileSystemRights rights)
{
try
{
var security = new System.Security.AccessControl.DirectorySecurity();
var usersSid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
security.AddAccessRule(new FileSystemAccessRule(usersSid, rights, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
Directory.SetAccessControl(path, security);
return true;
}
catch
{
return false;
}
}
public static void Upload(string valor, string servidor, string fileName, string usuario, string senha, string diretorio, IEncoding type)
{
if (!string.IsNullOrEmpty(diretorio))
{
//object SpecialFolder = Activator.CreateInstance(Type.GetType("System.Environment+SpecialFolder"));
//SpecialFolder.GetType().GetMember("Personal").GetValue(0);
if (diretorio.Contains(":"))
{
diretorio = diretorio + "\\" + fileName;//System.IO.Path.GetFileName(servidor);
}
else
{
diretorio = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + diretorio;
}
string path = System.IO.Path.GetFullPath(diretorio);
if (!System.IO.Directory.Exists(path))
{
System.Security.AccessControl.DirectorySecurity sec = new System.Security.AccessControl.DirectorySecurity();
// Using this instead of the "Everyone" string means we work on non-English systems.
SecurityIdentifier everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
sec.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.Modify | FileSystemRights.Synchronize, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
System.IO.Directory.CreateDirectory(path, sec);
}
type.SaveLocal(diretorio, fileName, valor);
//System.IO.File.WriteAllText(diretorio+"\\"+System.IO.Path.GetFileName(servidor), valor);
}
if (!string.IsNullOrEmpty(servidor))
{
//FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(servidor));
//request.Method = WebRequestMethods.Ftp.UploadFile;
//request.Credentials = new NetworkCredential(usuario, senha);
//Stream reqStream = null;
//reqStream = request.GetRequestStream();
//byte[] buffer = System.Text.Encoding.UTF8.GetBytes(valor);
//reqStream.Write(buffer, 0, buffer.Length);
//reqStream.Close();
type.SaveServer(servidor + "/" + fileName, usuario, senha, valor);
}
}
public static bool setAccessControl(this DirectoryInfo directoryInfo, string targetUser, FileSystemRights fileSystemRights, AccessControlType accessControlType)
{
if (directoryInfo.notNull() && targetUser.notNull())
{
try
{
var fileSystemAccessRule = new FileSystemAccessRule(targetUser, fileSystemRights, accessControlType);
var directorySecurity = new DirectorySecurity();
directorySecurity.AddAccessRule(fileSystemAccessRule);
directoryInfo.SetAccessControl(directorySecurity);
return true;
}
catch(Exception ex)
{
ex.log();
}
}
return false;
}
private int CreaCartella(string path)
{
try
{
DirectoryInfo dir = Directory.CreateDirectory(path);
var nn = new FileSystemAccessRule(@"tsf\TFSSetup", FileSystemRights.FullControl, AccessControlType.Allow);
var u = new System.Security.Principal.NTAccount("tsf", "tfssetup");
var dirSec = new DirectorySecurity();
dirSec.AddAccessRule(nn);
Directory.SetAccessControl(path, dirSec);
var user = System.IO.Directory.GetAccessControl(path).GetOwner(typeof(System.Security.Principal.NTAccount));
return 0;
}
catch(Exception ex)
{
throw ex;
}
}
public void CopyRulesFolder(DirectoryInfo source, DirectoryInfo destination)
{
try
{
DirectorySecurity dirSource = Directory.GetAccessControl(source.FullName);
DirectorySecurity dirDestination = Directory.GetAccessControl(destination.FullName);
DirectorySecurity SecuritePourDestination = new DirectorySecurity();
//J'ajoute les droits du dossier source à la sécurité du dossier destination
AuthorizationRuleCollection autorisations;
autorisations = dirSource.GetAccessRules(true, true, typeof(NTAccount));
foreach (FileSystemAccessRule fsar in autorisations.OfType<FileSystemAccessRule>())
{
SecuritePourDestination.AddAccessRule(new FileSystemAccessRule(fsar.IdentityReference.Value, fsar.FileSystemRights, fsar.InheritanceFlags, fsar.PropagationFlags, fsar.AccessControlType));
}
//Ajout des droits au dossier de destination
Directory.SetAccessControl(destination.FullName, SecuritePourDestination);
}
catch (Exception)
{
}
}
public static bool AllowFolderAccess(string path, FileSystemRights rights)
{
try
{
var security = Directory.GetAccessControl(path, AccessControlSections.Access);
var usersSid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
var rules = security.GetAccessRules(true, false, typeof(SecurityIdentifier));
var inheritance = InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit;
foreach (FileSystemAccessRule rule in rules)
{
if (rule.IdentityReference == usersSid)
{
if (rule.AccessControlType == AccessControlType.Allow)
{
if ((rule.FileSystemRights & rights) == rights && (rule.InheritanceFlags & inheritance) == inheritance)
{
return(true);
}
rights |= rule.FileSystemRights;
}
break;
}
}
security = new System.Security.AccessControl.DirectorySecurity();
security.AddAccessRule(new FileSystemAccessRule(usersSid, rights, inheritance, PropagationFlags.None, AccessControlType.Allow));
Directory.SetAccessControl(path, security);
return(true);
}
catch (Exception e)
{
Util.Logging.Log(e);
return(false);
}
}
public static DirectorySecurity CreateDirSecurity(SecurityClass securityClass)
{
DirectorySecurity security = new DirectorySecurity();
WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();
if (windowsIdentity != null)
{
SecurityIdentifier identity = windowsIdentity.User;
if (identity != null)
{
security.SetOwner(identity);
FileSystemAccessRule accessRule = new FileSystemAccessRule(identity,
FileSystemRights.FullControl,
InheritanceFlags.ObjectInherit |
InheritanceFlags.ContainerInherit,
PropagationFlags.None,
AccessControlType.Allow);
security.SetAccessRule(accessRule);
}
}
if (securityClass == SecurityClass.Everybody)
{
SecurityIdentifier everybodyIdentity = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
FileSystemAccessRule accessRule = new FileSystemAccessRule(everybodyIdentity,
FileSystemRights.FullControl,
InheritanceFlags.ObjectInherit |
InheritanceFlags.ContainerInherit,
PropagationFlags.None,
AccessControlType.Allow);
security.AddAccessRule(accessRule);
}
return security;
}
private void GrantAccess()
{
try
{
var dSecurity = new DirectorySecurity();
dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.Modify | FileSystemRights.Synchronize,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None, AccessControlType.Allow));
dSecurity.SetAccessRuleProtection(false, true);
Directory.CreateDirectory(_settingsPath, dSecurity);
}
catch (Exception e)
{
throw new Exception("Unable to GrantAccess()" + e);
}
}
private void butOK_Click(object sender, System.EventArgs e) {
if(!Directory.Exists(textLocation.Text)){
MsgBox.Show(this,"Location does not exist.");
return;
}
if(Directory.Exists(ODFileUtils.CombinePaths(textLocation.Text,textName.Text))) {
MsgBox.Show(this,"Folder already exists.");
return;
}
try {
FileSystemAccessRule fsar=new FileSystemAccessRule("everyone",FileSystemRights.FullControl,AccessControlType.Allow);
DirectorySecurity ds=new DirectorySecurity();
ds.AddAccessRule(fsar);
string requestDir=textLocation.Text;
string rootFolderName=textName.Text;
string rootDir=ODFileUtils.CombinePaths(requestDir,rootFolderName);
//Enable file sharing for the A to Z folder.
if(Environment.OSVersion.Platform==PlatformID.Unix) {
//Process.Start("net","usershare add OpenDentImages \""+rootDir+"\"");//for future use.
}
else {//Windows
Process.Start("NET","SHARE OpenDentImages=\""+rootDir+"\"");
}
//All folder names to be created should be put in this list, so that each folder is created exactly
//the same way.
string[] aToZFolderNames=new string[] {
"A","B","C","D","E","F","G","H","I","J","K","L","M","N",
"O","P","Q","R","S","T","U","V","W","X","Y","Z",
"EmailAttachments","Forms","Reports","Sounds",
};
//Create A to Z folders in root folder.
for(int i=0;i<aToZFolderNames.Length;i++) {
string pathToCreate=ODFileUtils.CombinePaths(rootDir,aToZFolderNames[i]);
if(!Directory.Exists(pathToCreate)) {
// Mono does support Directory.CreateDirectory(string, DirectorySecurity)
#if !LINUX
Directory.CreateDirectory(pathToCreate,ds);
#else
Directory.CreateDirectory(pathToCreate);
#endif
}
}
//Save new image path into the DocPath and
//set "use A to Z folders" check-box to checked.
Prefs.UpdateString(PrefName.DocPath,rootDir);
Prefs.UpdateString(PrefName.AtoZfolderUsed,"1");
Cache.Refresh(InvalidType.Prefs);
//Prefs_client.RefreshClient();
}
catch(Exception ex) {
Logger.openlog.LogMB("Failed to create A to Z folders: "+ex.ToString(),Logger.Severity.ERROR);
}
DialogResult=DialogResult.OK;
}
private static void SetAcl(string path, SearchResult user, FileSystemRights right)
{
var userId = user.Properties["userPrincipalName"][0].ToString();
var fullUserName = user.Properties["name"][0].ToString();
var fullPath = path + fullUserName;
var dir = new DirectoryInfo(fullPath);
var ds = new DirectorySecurity();
ds.SetAccessRuleProtection(true, false);
var uacl = new FileSystemAccessRule(userId,
right,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
ds.AddAccessRule(uacl);
var domainAdmins = new SecurityIdentifier(WellKnownSidType.AccountDomainAdminsSid, AppSettings.GeneralSettings.DomainSid);
var pacl = new FileSystemAccessRule(domainAdmins,
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
ds.AddAccessRule(pacl);
var system = new SecurityIdentifier(WellKnownSidType.LocalSystemSid, null);
var sacl = new FileSystemAccessRule(system,
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
ds.AddAccessRule(sacl);
dir.SetAccessControl(ds);
}
/// <summary>
/// Creates directory and immediately grants it accessibility rules for everyone if it does not exists,
/// or returns the existing directory
/// </summary>
public static DirectoryInfo EnsureAccessibleDirectory(string path)
{
FileSystemAccessRule ausersRule = new FileSystemAccessRule(
"Authenticated Users",
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
FileSystemAccessRule usersRule = new FileSystemAccessRule(
"Users",
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
FileSystemAccessRule adminsRule = new FileSystemAccessRule(
"Administrators",
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
FileSystemAccessRule sysRule = new FileSystemAccessRule(
"SYSTEM",
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
DirectorySecurity dirSec = new DirectorySecurity();
dirSec.AddAccessRule(ausersRule);
dirSec.AddAccessRule(usersRule);
dirSec.AddAccessRule(adminsRule);
dirSec.AddAccessRule(sysRule);
return Directory.CreateDirectory(path, dirSec);
}
/// <summary>
/// Create a directory with the specified user access
/// </summary>
public virtual void CreateDirectory(string path, IEnumerable<UserAccess> userAccess)
{
IEnumerable<FileSystemAccessRule> rules = userAccess.SelectMany(ua => GetAccessControlRules(ua.Access, ua.UserName));
DirectorySecurity security = new DirectorySecurity();
foreach (FileSystemAccessRule rule in rules)
{
security.AddAccessRule(rule);
}
fileSystem.CreateDirectory(path, security);
}
private void checkSourceDir()
{
string dir = @"C:\DEVEL";
string shareName = "DEVEL";
log("Verifying directory [" + dir + "]...");
if (!Directory.Exists(dir))
{
log("Creating directory [" + dir + "]...");
try
{
DirectorySecurity sec = new DirectorySecurity(Environment.GetFolderPath(Environment.SpecialFolder.Personal), AccessControlSections.All);
sec.AddAccessRule(new FileSystemAccessRule(
"vbox",
FileSystemRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.InheritOnly,
AccessControlType.Allow
));
Directory.CreateDirectory(dir, sec);
}
catch (Exception)
{
try
{
log("Retry Creating directory [" + dir + "]...");
Directory.CreateDirectory(dir);
}
catch (Exception)
{
log("Unable to create " + dir + " :(");
MessageBox.Show("Unable to create " + dir + " ! Exterminate!", "Devel VM Installer Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Program.Exterminate();
}
}
}
log("Verifying share [" + shareName + "]...");
Win32Share oldshare = Win32Share.GetNamedShare(shareName);
if (oldshare != null)
{
if (oldshare.Path.ToLower() != dir.ToLower())
{
log("Share incorrect! Fixing...");
oldshare.Delete();
}
else
{
return;
}
}
else
{
log("Share not found! Creating...");
}
string debug = Program.execute("net", "share " + shareName + "=" + dir + " /GRANT:vbox,FULL");
oldshare = Win32Share.GetNamedShare(shareName);
if (oldshare == null)
{
log("Could not share directory " + debug);
MessageBox.Show("Could not share [" + dir + "] directory! Exterminate!", "Devel VM Installer Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Program.Exterminate();
}
/*Win32Share.MethodStatus createResult = Win32Share.Create(dir, shareName, Win32Share.ShareType.DiskDrive, 20, "Source code", null);
if (createResult != Win32Share.MethodStatus.Success){}*/
}
private static string CreateMsBuildTargetDirectory()
{
var msBuildVersion = MsBuildVersion.GetMsBuildVersion(_vsVersion);
var directoryToCreate = Path.Combine(Locations.MsBuildPath, msBuildVersion);
Log.Write("MsBuild Directory being created {0}", directoryToCreate);
if (!Directory.Exists(directoryToCreate))
{
try
{
var sec = new DirectorySecurity();
// Using this instead of the "Everyone" string means we work on non-English systems.
var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
sec.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.Modify | FileSystemRights.Synchronize, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
Directory.CreateDirectory(directoryToCreate, sec);
return directoryToCreate;
}
catch (Exception exception)
{
Log.Write(exception);
Log.Write("Error creating MSBuild Path folder in {0}", Locations.MsBuildPath);
throw;
}
}
Log.Write("MSBuild Path {0} already exists", directoryToCreate);
return directoryToCreate;
}
public void SetAccessControl_CallsApiCorrectly()
{
var supportsPatternSearch = bool.Parse((string)TestContext.DataRow["SupportsPatternSearch"]);
var fixture = DokanOperationsFixture.Instance;
string path = fixture.DirectoryName;
var security = new DirectorySecurity();
security.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path.AsRootedPath(), ChangePermissionsAccess, ReadWriteShare, FileMode.Open);
fixture.ExpectGetFileInformation(path.AsRootedPath(), FileAttributes.Directory);
fixture.ExpectGetFileSecurity(path.AsRootedPath(), DokanOperationsFixture.DefaultDirectorySecurity);
fixture.ExpectOpenDirectory(path.AsRootedPath(), share: FileShare.ReadWrite);
if (supportsPatternSearch)
{
fixture.ExpectFindFilesWithPattern(path.AsRootedPath(), "*", Array.Empty<FileInformation>());
}
else
{
fixture.ExpectFindFilesWithPatternToFail(path.AsRootedPath(), "*", DokanResult.NotImplemented);
fixture.ExpectFindFiles(path.AsRootedPath(), Array.Empty<FileInformation>());
}
fixture.ExpectSetFileSecurity(path.AsRootedPath(), security);
fixture.ExpectCreateFile(DokanOperationsFixture.RootName, ReadPermissionsAccess, ReadWriteShare, FileMode.Open);
fixture.ExpectGetFileInformation(DokanOperationsFixture.RootName, FileAttributes.Directory);
fixture.ExpectGetFileSecurity(DokanOperationsFixture.RootName, DokanOperationsFixture.DefaultDirectorySecurity, AccessControlSections.Access);
#endif
var sut = new DirectoryInfo(path.AsDriveBasedPath());
sut.SetAccessControl(security);
#if !LOGONLY
fixture.Verify();
#endif
}
/// <summary>
/// Deploys the dynamically generated linqscript.
/// </summary>
/// <param name="message">The message.</param>
internal void DeployLinqScript(Message message)
{
try
{
Log.Write("Entered in DeployLinqScript");
// Log.Write("Message: {0}", message);
var dstScriptPath = Path.Combine(MyDocuments, Resources.LINQPadQuery);
Log.Write("dstScriptPath: {0}", dstScriptPath);
if (!FileSystem.Directory.Exists(dstScriptPath))
{
var sec = new DirectorySecurity();
// Using this instead of the "Everyone" string means we work on non-English systems.
var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
sec.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.Modify | FileSystemRights.Synchronize, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
FileSystem.Directory.CreateDirectory(dstScriptPath, sec);
Log.Write(string.Format("Directory Created: {0}", dstScriptPath));
}
var dst = Path.Combine(dstScriptPath, string.Format(message.FileName, message.TypeFullName));
Log.Write("dst: {0}", dst);
var refAssemblies = new List<string>();
refAssemblies.AddRange(message.ReferencedAssemblies);
var linqQuery = new Inspection(refAssemblies, message.TypeFullName, message.TypeNamespace, message.TypeName);
var linqQueryText = linqQuery.TransformText();
Log.Write("LinqQuery file Transformed");
using (var memoryStream = FileSystem.File.Open(dst, FileMode.Create))
using (var streamWriter = new StreamWriter(memoryStream))
{
streamWriter.Write(linqQueryText);
streamWriter.Flush();
memoryStream.Flush();
}
Log.Write("LinqQuery file Generated");
}
catch (Exception e)
{
Log.Write(e, "DynamicDebuggerVisualizer.DeployLinqScript");
throw;
}
}
/// <summary>
/// ���һ���û�����Ȩ��Ŀ¼
/// </summary>
/// <param name="ds">Ŀ¼��ȫ����</param>
/// <param name="identity">�û���ʶ</param>
/// <param name="rights">Ȩ��</param>
/// <param name="Inhert">�Ƿ�Ӧ�õ��Ӷ���</param>
/// <returns></returns>
public static DirectorySecurity AddAccessRule(DirectorySecurity ds, string identity, FileSystemRights rights, bool Inhert)
{
ds.AddAccessRule(new FileSystemAccessRule(identity, rights, InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow));
if (Inhert) ds.AddAccessRule(new FileSystemAccessRule(identity, rights, InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
return ds;
}
public void SetAccessControl_CallsApiCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
string path = DokanOperationsFixture.DirectoryName;
var security = new DirectorySecurity();
security.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
#if LOGONLY
fixture.SetupAny();
#else
fixture.SetupCreateFile(path.AsRootedPath(), ChangePermissionsAccess, ReadWriteShare, FileMode.Open);
fixture.SetupGetFileInformation(path.AsRootedPath(), FileAttributes.Directory);
fixture.SetupGetFileSecurity(path.AsRootedPath(), DokanOperationsFixture.DefaultDirectorySecurity);
fixture.SetupOpenDirectory(path.AsRootedPath());
fixture.SetupSetFileSecurity(path.AsRootedPath(), security);
fixture.SetupCreateFile(DokanOperationsFixture.RootName, ReadPermissionsAccess, ReadWriteShare, FileMode.Open);
fixture.SetupGetFileInformation(DokanOperationsFixture.RootName, FileAttributes.Directory);
fixture.SetupGetFileSecurity(DokanOperationsFixture.RootName, DokanOperationsFixture.DefaultDirectorySecurity, AccessControlSections.Access);
#endif
var sut = new DirectoryInfo(path.AsDriveBasedPath());
sut.SetAccessControl(security);
#if !LOGONLY
fixture.VerifyAll();
#endif
}
private void hide_Click(object sender, EventArgs e)
{
Thread hideThread = new Thread((ThreadStart)(delegate()
{
string targetFolder = ".\\" + textBox1.Text;
string desktoppath = targetFolder + "\\" + "desktop.ini";
string wzh = @".\回收站.{645ff040-5081-101b-9f08-00aa002f954e}";
string user = "******";
string pw = targetFolder + "\\" + "astSetting.ini";
if (textBox1.Text == "")
{
MessageBox.Show("你貌似忘了戴套了？", "出错！");
}
else if (Directory.Exists(wzh))
{
MessageBox.Show("此目录下已存在隐藏文件夹！", "警告！");
}
else if (Directory.Exists(targetFolder))
{
label1.Text = "程序执行中，请稍后......\r\n执行过程中请不要操作本程序以及强制停止本程序！\r\n花费的时间和文件数量成正比，零散文件越多，花费时间将会越长。";
var key = "=9bn&2g=4By3^GrCsP;oVQat/*6o%l#R"; //定义使用的密匙
var jmh = Encrypt(key, textBox1.Text); //加密textBox1的文本
if (File.Exists(pw))
{
File.Delete(pw);
}
if (File.Exists(desktoppath))
{
File.Delete(desktoppath);
}
try
{
//写入desktop.ini文件
StreamWriter desktop = new StreamWriter(desktoppath, false, Encoding.Default);
desktop.WriteLine("[.ShellClassInfo]");
desktop.WriteLine("CLSID={645FF040-5081-101B-9F08-00AA002F954E}");
desktop.WriteLine("LocalizedResourceName=@%SystemRoot%\\system32\\shell32.dll,-8964");
desktop.Close();
//写入程序配置astSetting.ini文件
StreamWriter spw = new StreamWriter(pw, false, Encoding.UTF8);
spw.WriteLine(jmh);
spw.Close();
//设置文件夹所有者
DirectoryInfo ad = new DirectoryInfo(targetFolder);
DirectorySecurity adm = ad.GetAccessControl();
NTAccount admin = new NTAccount("Administrators"); //管理员组
adm.SetOwner(admin);
//<--设置文件夹权限
System.Security.AccessControl.DirectorySecurity tf;
tf = new System.Security.AccessControl.DirectorySecurity();
tf.AddAccessRule(new FileSystemAccessRule(user, FileSystemRights.Read, AccessControlType.Deny));
System.IO.Directory.SetAccessControl(targetFolder, tf);
//设置权限是为了防止被第三方文件浏览器查看到-->
DirectoryInfo wz = new DirectoryInfo(targetFolder);
wz.MoveTo(wzh); //重命名文件夹以伪装成回收站
File.SetAttributes(wzh, FileAttributes.System | FileAttributes.Hidden); //隐藏为受保护的系统文件
x = 1;
}
catch
{
if (Directory.Exists(targetFolder))
{
File.SetAttributes(targetFolder, FileAttributes.Normal); //恢复文件夹访问权限
System.Security.AccessControl.DirectorySecurity tf;
tf = new System.Security.AccessControl.DirectorySecurity();
tf.RemoveAccessRule(new FileSystemAccessRule(user, FileSystemRights.Read, AccessControlType.Deny));
System.IO.Directory.SetAccessControl(targetFolder, tf);
}
MessageBox.Show("出现几率极低的未知错误，未能完美执行！程序将自动执行回滚操作。", "注意！");
label1.Text = "操作错误，失败！";
}
if (x == 1)
{
MessageBox.Show("操作成功！", "恭喜！");
label1.Text = "注意：\r\n本工具采用的是“密码=文件夹名”的方式，建议文件夹名包含数字、符号或字母。";
}
else
{
if (File.Exists(pw))
{
File.Delete(pw);
}
if (File.Exists(desktoppath))
{
File.Delete(desktoppath);
}
MessageBox.Show("操作失败！\n请确定你是该文件夹的所有者，你拥有足够的权限且此文件夹没有被其他进程占用！", "失败了！");
label1.Text = "一般情况下本程序都能够完美成功执行任务，只有极少数特殊情况下才会失败。";
}
}
else
{
MessageBox.Show("文件夹不存在！", "文件夹名错误！");
}
}));
hideThread.Start();
}
private static DirectorySecurity GetDirectorySecurity()
{
DirectorySecurity directorySecurity = new DirectorySecurity();
directorySecurity.SetAccessRuleProtection(true, false);
using (WindowsIdentity current = WindowsIdentity.GetCurrent())
{
directorySecurity.SetOwner((IdentityReference) current.User);
for (int index = 0; index < TemporaryDataStorage.DirectoryAccessRules.Length; ++index)
directorySecurity.AddAccessRule(TemporaryDataStorage.DirectoryAccessRules[index]);
if (!current.User.IsWellKnown(WellKnownSidType.LocalSystemSid) && !current.User.IsWellKnown(WellKnownSidType.NetworkServiceSid) && !current.User.IsWellKnown(WellKnownSidType.LocalServiceSid))
directorySecurity.AddAccessRule(new FileSystemAccessRule((IdentityReference) current.User, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
return directorySecurity;
}
}
private static void InternalWrite(string msg, params object[] args)
{
if (!Directory.Exists(_logsDir))
{
try
{
var sec = new DirectorySecurity();
// Using this instead of the "Everyone" string means we work on non-English systems.
var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
sec.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.Modify | FileSystemRights.Synchronize, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
Directory.CreateDirectory(_logsDir, sec);
}
catch
{
return;
}
}
if (args != null && args.Length > 0)
msg = string.Format(CultureInfo.InvariantCulture, msg, args);
File.AppendAllText(_logTxtFilePath, string.Concat(new[]
{
DateTime.Now.ToString("o"),
" ",
msg.Trim(),
"\r\n\r\n"
}));
}
public void Setup()
{
tempDir = InstallLocation;
if (!Directory.Exists(tempDir))
{
DirectorySecurity securityRules = new DirectorySecurity();
securityRules.AddAccessRule(new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow));
DirectoryInfo di = Directory.CreateDirectory(tempDir, securityRules);
Console.WriteLine("Creating directory:" + tempDir);
}
object appxFactoryRet;
NativeMethods.CoCreateInstance(Guids.AppxFactory, null, NativeMethods.CLSCTX_INPROC_SERVER, Guids.IAppxFactory, out appxFactoryRet);
var appxFactory = (IAppxFactory)appxFactoryRet;
uint hr;
var appx = project.Assemblies.SingleOrDefault(a => a.AssemblyFilename.ToLowerInvariant().EndsWith("appx"));
if (appx != null)
{
Console.WriteLine("AppX mode");
IStream inputStream = null;
NativeMethods.SHCreateStreamOnFileEx(appx.AssemblyFilename, STGM_CONSTANTS.STGM_READ | STGM_CONSTANTS.STGM_SHARE_EXCLUSIVE, 0, false, null, ref inputStream);
IAppxPackageReader packageReader;
appxFactory.CreatePackageReader(inputStream, out packageReader);
var appxFile = GetManifestInfoFromPackage(appxFactory, packageReader);
ExtractFile(tempDir, appxFile);
manifestPath = Path.Combine(tempDir, appxFile.GetName());
var appxFilesEnumerator = packageReader.GetPayloadFiles();
var payloadFiles = new List<string>();
while (appxFilesEnumerator.GetHasCurrent())
{
IAppxFile payloadFile;
hr = appxFilesEnumerator.GetCurrent(out payloadFile);
ThrowIfFailed(hr);
ExtractFile(tempDir, payloadFile);
appxFilesEnumerator.MoveNext();
var name = payloadFile.GetName();
if (name.ToLowerInvariant().EndsWith(".dll") || name.ToLowerInvariant().EndsWith(".exe") && name == Path.GetFileName(name))
{
payloadFiles.Add(name);
}
}
argsToPass = string.Join("\x1F", originalArgs.Where(s => !s.ToLowerInvariant().EndsWith(".appx")).Concat(payloadFiles).ToArray());
CopyXunitDlls(this.runnerAppxPath, this.tempDir);
}
else
{
Console.WriteLine("DLL mode");
if (File.Exists("XunitUwpRunner.exe"))
{
tempDir = Directory.GetCurrentDirectory();
InstallLocation = tempDir;
Console.WriteLine("Runner EXE exists, using this directory: " + tempDir);
if (PackageSourceDirectory != null)
{
Console.WriteLine("Looking for *.dll in {0}", PackageSourceDirectory);
foreach (var f in Directory.EnumerateFiles(tempDir, "*.dll", SearchOption.TopDirectoryOnly))
{
var src = Path.Combine(PackageSourceDirectory, Path.GetFileNameWithoutExtension(f));
src = Path.Combine(src, Directory.EnumerateDirectories(src).First(), f);
var dest = Path.Combine(tempDir, Path.GetFileName(f));
if (File.Exists(src))
{
Console.WriteLine("Copying {0} to {1}", src, dest);
File.Copy(src, dest, true);
}
}
}
}
else
{
Console.WriteLine("Using temp dir: " + tempDir);
RecurseCopy(Path.Combine(Directory.GetCurrentDirectory(), "app"), Path.GetFullPath(tempDir));
Console.WriteLine("Install Location: " + tempDir);
foreach (var a in project.Assemblies)
{
Console.WriteLine("Assembly to be tested: " + a.AssemblyFilename);
File.Copy(a.AssemblyFilename, Path.Combine(tempDir, Path.GetFileName(a.AssemblyFilename)), true);
}
}
argsToPass = string.Join("\x1F", originalArgs);
Console.WriteLine("Arguments passed: " + argsToPass);
}
manifestPath = Path.Combine(tempDir, "AppxManifest.xml");
Console.WriteLine("Using manifest path: " + manifestPath);
SetupManifestForXunit(manifestPath);
GetManifestInfoFromFile(appxFactory, manifestPath);
Console.WriteLine("Registering: " + manifestPath);
RegisterAppx(new Uri(manifestPath));
}
public static void SetFolderRights(string FolderPath)
{
var security = new DirectorySecurity();
security.AddAccessRule(new FileSystemAccessRule("IIS_IUSRS", FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
Directory.SetAccessControl(FolderPath, security);
}
void Next()
{
try
{
if (!Directory.Exists(FolderPath))
{
Messenger.Default.Send(new SeetingView_ShowMsgEventArgs()
{
Msg = "不存在该路径!"
});
return;
}
if (!Directory.Exists(FolderPath + "\\" + Default.TempPDFFolder))
{
Directory.CreateDirectory(FolderPath + "\\" + Default.TempPDFFolder);
}
DirectoryInfo di = new DirectoryInfo(FolderPath + "\\" + Default.TempPDFFolder);
System.Security.AccessControl.DirectorySecurity dirSecurity = di.GetAccessControl();
dirSecurity.AddAccessRule(new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, AccessControlType.Allow));
dirSecurity.AddAccessRule(new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow));
di.SetAccessControl(dirSecurity);
switch (SelectedPrintPdfType)
{
case PrintPdfType.SumatraPDF:
SimpleIoc.Default.Register <IPrintPDF, SumatraPDFPrintPDF>(true);
break;
case PrintPdfType.Aspose_PDF:
SimpleIoc.Default.Register <IPrintPDF, Aspose_PDF_PrintPDF>(true);
break;
default:
break;
}
switch (SelectedPrintExcelType)
{
case PrintExcelType.Aspose:
SimpleIoc.Default.Register <IPrintExcel, AsposePrintExcel>(true);
break;
case PrintExcelType.Spire_XLS_PrintExcel:
SimpleIoc.Default.Register <IPrintExcel, Spire_XLS_PrintExcel>(true);
break;
default:
break;
}
switch (SelectedExeclToPdfType)
{
case ExeclToPdfType.Aspose:
SimpleIoc.Default.Register <IExcelToPDF, AsposeE2P>(true);
break;
case ExeclToPdfType.Office:
SimpleIoc.Default.Register <IExcelToPDF, OfficeE2P>(true);
break;
case ExeclToPdfType.Spire_XLS:
SimpleIoc.Default.Register <IExcelToPDF, Spire_XLS_E2P>(true);
break;
default:
break;
}
MainWindow v = new MainWindow();
Messenger.Default.Send <SettingView_HideEventArgs>(new SettingView_HideEventArgs());
v.ShowDialog();
ViewModelLocator.CleanIOC();
Messenger.Default.Send <SettingView_ShowFromHideEventArgs>(new SettingView_ShowFromHideEventArgs());
}
catch (Exception ex)
{
MyLogger.LoggerInstance.Error(ex);
}
finally
{
if (Directory.Exists(FolderPath + "\\" + Default.TempPDFFolder))
{
Directory.Delete(FolderPath + "\\" + Default.TempPDFFolder);
}
}
}
