/** * the function close server after call to the close */ public void closeServer(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler h = (IDirectoryHandler)sender; CommandRecieved -= h.OnCommandRecieved; m_logging.Log("close service: " + e.Message, MessageTypeEnum.INFO); }
/// <summary> /// close specific handler /// </summary> /// <param name="sender"> the object calling to this function </param> /// <param name="eventArgs"> the event args of closing a handler </param> private void CloseHandler(object sender, DirectoryCloseEventArgs eventArgs) { IDirectoryHandler dirHandler = (IDirectoryHandler)sender; CommandRecieved -= dirHandler.OnCommandRecieved; dirHandler.DirectoryClose -= CloseHandler; }
public DirectoryWebSocketService(IWebSocketHandler webSocketHandler, IDirectoryHandler directoryHandler, IDebugHandler debugHandler) { debugHandler.TraceMessage("Constructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT); DebugHandler = debugHandler; WebSocketHandler = webSocketHandler; DirectoryHandler = directoryHandler; }
/************************************************************************ * The Input: sender and an event. * The Output: - * The Function operation: The function is called when the handler is closed. *************************************************************************/ public void OnHandlerClose(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler dirHandler = (IDirectoryHandler)sender; CommandReceived -= dirHandler.OnCommandRecieved; m_logging.Log("Stop handle directory " + e.Message, Logging.Modal.MessageTypeEnum.INFO); }
public event EventHandler <CommandRecievedEventArgs> CommandRecieved; // The event that notifies about a new Command being recieved #endregion /*********************************************************************/ public void onCloseServer(object sender, ...) { IDirectoryHandler h = sender; CommandRecieved -= h.OnCommandRecieved(sender, CommandRecieved); CommandRecieved -= h.OnCloseServer; }
public DownloadWebSocketService( IWebSocketHandler webSocketHandler, IDirectoryHandler directoryHandler, IDownloadHandler downloadHandler, IFileHandler fileHandler, IFileHistoryHandler fileHistoryHandler, ISettingsHandler settingsHandler, IDebugHandler debugHandler) { debugHandler.TraceMessage("Constructor called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT); DebugHandler = debugHandler; WebSocketHandler = webSocketHandler; DirectoryHandler = directoryHandler; DownloadHandler = downloadHandler; FileHandler = fileHandler; FileHistoryHandler = fileHistoryHandler; SettingsHandler = settingsHandler; LastDownloadedInfo = new JsonDownloadInfo(); LittleWeebSettings = SettingsHandler.GetLittleWeebSettings(); IrcSettings = SettingsHandler.GetIrcSettings(); downloadHandler.OnDownloadUpdateEvent += OnDownloadUpdateEvent; }
/// <summary> /// removing a handler from the list of the handlers /// </summary> /// <param name="path">the path of the directory that need to stop handling</param> /// <returns>the result of action (success or failure)</returns> public string RemoveHandler(string path) { bool sucsses = false; string newHandlersList = ""; IDirectoryHandler chosenHandler = null; foreach (IDirectoryHandler handler in this.listOfHandlers) { if (handler.GetPath() == path) { chosenHandler = handler; sucsses = true; } else { newHandlersList += (handler.GetPath() + ";"); } } if (chosenHandler != null) { chosenHandler.CloseHandler(path); ConfigurationManager.AppSettings.Set("Handler", newHandlersList); this.m_logging.Log("The handler of " + path + " removed", MessageTypeEnum.INFO); Thread.Sleep(100); } if (sucsses) { return("sucsses"); } return("failure"); }
public GameController(IGameSettings gameSettings, int rX, int rY, GraphicsMode graphicsMode, string title, int major, int minor, IDirectoryHandler directoryHandler) : base(rX, rY, graphicsMode, title, GameWindowFlags.Default, DisplayDevice.Default, major, minor, GraphicsContextFlags.Default) { // Add OpenGL/GPU information tags to sentry var glVersion = GL.GetString(StringName.Version); var glslVersion = GL.GetString(StringName.ShadingLanguageVersion); var gpuVendor = GL.GetString(StringName.Vendor); var renderer = GL.GetString(StringName.Renderer); ServiceLocator.ErrorReporting.AddTags(new Dictionary <string, string> { { "opengl", glVersion }, { "glsl", glslVersion }, { "vendor", gpuVendor }, { "gpu", renderer } }); // Add backend information tags to sentry var sdl = Configuration.RunningOnSdl2; Console.WriteLine("Running on SDL2: {0}", sdl); ServiceLocator.ErrorReporting.AddTags(new Dictionary <string, string> { { "sdl", sdl.ToString() } }); KeyDown += Keyboard_KeyDown; this.VSync = (bool)gameSettings["VSync"] ? VSyncMode.On : VSyncMode.Off; this.WindowState = (WindowState)Enum.Parse(typeof(WindowState), (string)gameSettings["WindowState"]); DebugMode.Value = (bool)gameSettings["Debug"]; _gameSettings = gameSettings; _directoryHandler = directoryHandler; }
public void OnCloseServer(object sender, DirectoryCloseEventArgs args) { IDirectoryHandler handler = (IDirectoryHandler)sender; onCommand -= handler.OnCommandRecieved; informHandlerClose -= handler.CloseHandler; handler.DirectoryClose -= OnCloseServer; }
/// <summary> /// removeHandler. /// remove handler from CommandRecieved event. /// </summary> /// <param name="source">source</param> /// <param name="args">arguments</param> public void removeHandler(object source, DirectoryCloseEventArgs args) { IDirectoryHandler toRemove = (IDirectoryHandler)source; this.CommandRecieved -= toRemove.OnCommandRecieved; this.m_logging.Log(args.Message, MessageTypeEnum.INFO); this.m_logging.Log("Handler closed", MessageTypeEnum.INFO); }
/// <summary> /// remove the directory handle from the CommanedRecived event /// </summary> /// <param name="sender"> sender class</param> /// <param name="e"> arguments of Directory close</param> public void CloseDirectory(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler d = (DirectoyHandler)sender; CommandRecieved -= d.OnCommandRecieved; d.DirectoryClose -= CloseDirectory; m_logging.Log(e.Message, MessageTypeEnum.INFO); }
/// <summary> /// Closes the handler. /// </summary> /// <param name="sender">The sender.</param> /// <param name="d">The <see cref="DirectoryCloseEventArgs"/> instance containing the close command.</param> public void CloseHandler(object sender, DirectoryCloseEventArgs d) { IDirectoryHandler idh = (IDirectoryHandler)sender; CommandReceived -= idh.OnCommandReceived; idh.DirectoryClose -= CloseHandler; handlersDict.Remove(d.DirectoryPath); }
/// <summary> /// close specific handler /// </summary> /// <param name="sender"> the object calling to this function </param> /// <param name="eventArgs"> the event args of closing a handler </param> private void CloseHandler(object sender, DirectoryCloseEventArgs eventArgs) { IDirectoryHandler dirHandler = (IDirectoryHandler)sender; CommandRecieved -= dirHandler.OnCommandRecieved; dirHandler.DirectoryClose -= CloseHandler; AppConfig.Instance.Folders.Remove(eventArgs.DirectoryPath); }
/// <summary> /// Deletes the handler. /// </summary> /// <param name="sender"> Sender. </param> /// <param name="e"> Event. </param> public void DeleteHandler(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler handler = (IDirectoryHandler)sender; CommandRecieved -= handler.OnCommandRecieved; handler.DirectoryClose -= DeleteHandler; m_logging.Log(e.Message + "directory is closed", Logging.Modal.MessageTypeEnum.INFO); }
/// <summary> /// Closes the server and logs the result. /// Param: Object sender, DirectoryCloseEventArgs args. /// </summary> public void OnCloseServer(Object sender, DirectoryCloseEventArgs args) { IDirectoryHandler h = (IDirectoryHandler)sender; CommandRecieved -= h.OnCommandRecieved; h.DirectoryClose -= OnCloseServer; m_logging.Log(args.DirectoryPath + args.Message, Logging.Modal.MessageTypeEnum.INFO); }
/// <summary> /// The function inform the server that a handler is done handle the dir. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> public void closeServer(object sender, DirectoryCloseEventArgs args) { _mLogging.Log(args.Message, MessageTypeEnum.INFO); IDirectoryHandler handler = (IDirectoryHandler)sender; CommandRecieved -= handler.OnCommandRecieved; handler.DirectoryClose -= closeServer; }
//informs the server that the handler has been closed public void OnCloseServer(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler closeHandler = (IDirectoryHandler)sender; this.CommandRecieved -= closeHandler.OnCommandRecieved; //removes the delegate of the current closed handler //informs the current handler has been closed this.m_logging.Log("The handler that handles the directory " + e.DirectoryPath + " has been closed", Logging.Modal.MessageTypeEnum.INFO); }
/// <summary> /// this method remove handler. /// </summary> /// <param name="source">object that send the event</param> /// <param name="e">args for the event</param> public void RemoveHandler(object source, DirectoryCloseEventArgs e) { IDirectoryHandler handler = (IDirectoryHandler)source; CommandRecieved -= handler.OnCommandRecieved; handler.DirectoryClose -= RemoveHandler; m_logging.Log(e.Message, MessageTypeEnum.INFO); }
/// <summary> /// the method get an handler and responsible to close the handler /// </summary> /// <param name="path">a string that represent the handler</param> public void closeHandler(string path) { IDirectoryHandler directory = this.handlers[path]; directory.onCloseService(this, null); CloseService -= directory.onCloseService; handlers.Remove(path); }
/// <summary> /// Subscribe events to the input directory handler. /// </summary> /// <param name="dirHandler">An IDirectoryHandler instance</param> private void SubscribeHandlerEvents(IDirectoryHandler dirHandler) { // Subscribing a command received function to the command event. CommandRecieved += dirHandler.OnCommandRecieved; // Subscribing a close handler function to the closing event. dirHandler.DirectoryClose += StopHandler; }
/// <summary> /// CloseSpecipicHandler function. /// closes specipic handler. /// </summary> /// <param name="toBeDeletedHandler">path of to be deleted handler</param> internal void CloseSpecipicHandler(string toBeDeletedHandler) { if (Handlers.ContainsKey(toBeDeletedHandler)) { IDirectoryHandler handler = Handlers[toBeDeletedHandler]; this.CloseServer -= handler.OnCloseHandler; handler.OnCloseHandler(this, null); } }
private FileConfigurationManager GetFileConfigurationManager(string name, IDirectoryHandler directory) { string configurationFilename = name + ".json"; if (!directory.IsFilePresent(configurationFilename)) return null; ITextHandler configurationFileHandler = directory.OpenFile(configurationFilename).CastFileHandler<ITextHandler>(); return new FileConfigurationManager(configurationFileHandler); }
private void OnDirectoryClose(object sender, Modal.DirectoryCloseEventArgs e) { IDirectoryHandler handler = sender as IDirectoryHandler; // Casting the Handler CommandRecieved -= handler.OnCommandRecieved; // Unsubscribing the Command // Notify To The Logger m_logging.Log(e.Message, Logging.Modal.MessageTypeEnum.INFO); // Notifying about the Logger the reason for closing the directory }
/// <summary> /// Create a handler object to every directory. /// </summary> /// <param name="serverParameters">IImageServerParameters object</param> /// <param name="modalParameters">IModalParameters modalParameters</param> private void CreateHandlers(IImageServerParameters serverParameters, IModalParameters modalParameters) { HandlersList = new List <IDirectoryHandler>(); foreach (string dir in serverParameters.Handlers) { IDirectoryHandler handler = CreateHandlerByDirectory(dir, modalParameters); HandlersList.Add(handler); } }
/// <summary> /// Delegate to run when the handler is being closed. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void OnHandlerClose(object sender, DirectoryCloseEventArgs e) { IDirectoryHandler dirHandler = (IDirectoryHandler)sender; CommandRecieved -= dirHandler.OnCommandRecieved; this.handlers.Remove(dirHandler); m_logging.Log("Stop handle directory " + e.Message, Logging.Model.MessageTypeEnum.INFO); this.server.SendClose(sender, e); }
/// <summary> /// Closes the specified handler. /// </summary> /// <param name="handlerToDelete">The handler to delete.</param> public void CloseSpecifiedHandler(string handlerToDelete) { if (handlers.ContainsKey(handlerToDelete)) { IDirectoryHandler handler = handlers[handlerToDelete]; this.CloseServer -= handler.OnCloseHandler; handler.OnCloseHandler(this, null); } }
public PaymentFileExportJob( IEmployeeSalaryService employeeSalaryService, IConfigurationProvider configurationProvider, IDirectoryHandler directoryHandler) { _employeeSalaryService = employeeSalaryService; _directoryHandler = directoryHandler; _configurationProvider = configurationProvider; }
/// <summary> /// This method is called when a directory is closing. /// </summary> /// <param name="sender">The command sender.</param> /// <param name="args">The directory close event arguments.</param> private void OnDirectoryClose(object sender, DirectoryCloseEventArgs args) { if (sender is IDirectoryHandler) { IDirectoryHandler directoryHandler = (IDirectoryHandler)sender; CommandRecieved -= directoryHandler.OnCommandRecieved; m_logging.Log(args.Message, MessageTypeEnum.INFO); } }
public LocalFileSystem(IDirectoryHandler directoryHandler) { _fileFilter = CSCore.Codecs.CodecFactory.Instance.GetSupportedFileExtensions(); _directoryHandler = directoryHandler; _drives = new List <FileBrowserEntry>(); _localFileSystemEntries = new List <FileBrowserEntry>(); _userFolders = new List <FileBrowserEntry>(); }
/// <summary> /// When a handler is closed, he will raise a event and this function will remove it from the CommandRecieved /// </summary> /// <param name="sender"> who was sent the event </param> /// <param name="d"> details about the handler </param> private void OnCloseHandler(object sender, DirectoryCloseEventArgs d) { IDirectoryHandler handler = (IDirectoryHandler)sender; CommandRecieved -= handler.OnCommandRecieved; m_appParsing.RemoveDir(handler.DirPath); RemoveHandlerFromClients(handler.DirPath); m_logging.Log(d.DirectoryPath + " " + d.Message, MessageTypeEnum.INFO); }
/// <summary> /// Closes the directory handler when required.. /// </summary> /// <param name="source"></param> /// <param name="args"></param> public void CloseHandler(object source, DirectoryCloseEventArgs args) { if (source is IDirectoryHandler) { IDirectoryHandler handler = (IDirectoryHandler)source; // future //HandlerDispatchCommand -= handler.OnCommandRecieved; } }
public override void Syncronize(IDirectoryHandler rootDirectoryHandler) { base.Syncronize(rootDirectoryHandler); IDirectoryHandler statsDirectory; if (!rootDirectoryHandler.IsFilePresent("Stats")) { statsDirectory = rootDirectoryHandler.CreateFile( "Stats", "directory", FileHandlerFactoryLocator.UserFactory.RootUser.Id).FileContainer.CastFileHandler<IDirectoryHandler>(); rootDirectoryHandler.SetPermission( null, "Stats", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.AnonymousUser.Id }, FilePermissionEnum.Read, false, false); } else statsDirectory = rootDirectoryHandler.OpenFile("Stats").CastFileHandler<IDirectoryHandler>(); if (!statsDirectory.IsFilePresent("CallHomeTracker")) { statsDirectory.CreateFile( "CallHomeTracker", "callhome", FileHandlerFactoryLocator.UserFactory.RootUser.Id); statsDirectory.SetPermission( null, "CallHomeTracker", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.AnonymousUser.Id }, FilePermissionEnum.Read, false, false); } }
/// <summary> /// The default Constructor. /// </summary> public SceneManager(GameWindow gameWindow, Camera camera, FontLibrary fontLibrary, string fontPath, IDirectoryHandler directoryHandler, IGameSettings gameSettings, ValueWrapper<bool> debug) { GameWindow = gameWindow; SceneList = new List<Scene>(); _scenesToAdd = new List<Scene>(); _scenesToRemove = new List<Scene>(); Directories = directoryHandler; FontPath = fontPath; GameFontLibrary = fontLibrary; DefaultFont = GameFontLibrary.GetFirstOrDefault(GameFontType.Default); FontDrawing = new QFontDrawing(); FontDrawing.ProjectionMatrix = camera.ScreenProjectionMatrix; ScreenCamera = camera; ScreenCamera.Center = Vector2.Zero; ScreenCamera.MaximumScale = new Vector2(10000, 10000); GameSettings = gameSettings; Debug = debug; }
public void RestoreFile(IFileId fileId, string pathToRestoreFrom, ID<IUserOrGroup, Guid> userId, IDirectoryHandler parentDirectory) { throw new NotImplementedException("File type isn't supported"); }
private void DoUpgrades(IDirectoryHandler rootDirectoryHandler) { IDirectoryHandler systemDirectory = rootDirectoryHandler.OpenFile("System").CastFileHandler<IDirectoryHandler>(); if (!systemDirectory.IsFilePresent("BrowserInfo")) { systemDirectory.CreateFile( "BrowserInfo", "browserinfo", FileHandlerFactoryLocator.UserFactory.RootUser.Id); systemDirectory.SetPermission( null, "BrowserInfo", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } if (!systemDirectory.IsFilePresent("Comet")) { IDirectoryHandler cometDirectory = (IDirectoryHandler)systemDirectory.CreateFile( "Comet", "directory", FileHandlerFactoryLocator.UserFactory.RootUser.Id); systemDirectory.SetPermission( null, "Comet", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); cometDirectory.CreateFile( "Loopback", "cometloopback", FileHandlerFactoryLocator.UserFactory.RootUser.Id); cometDirectory.SetPermission( null, "Loopback", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); cometDirectory.CreateFile( "Echo", "cometecho", FileHandlerFactoryLocator.UserFactory.RootUser.Id); cometDirectory.SetPermission( null, "Echo", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); cometDirectory.CreateFile( "Multiplexer", "cometmultiplex", FileHandlerFactoryLocator.UserFactory.RootUser.Id); cometDirectory.SetPermission( null, "Multiplexer", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); cometDirectory.CreateFile( "LoopbackQuality", "cometloopbackqueuingreliable", FileHandlerFactoryLocator.UserFactory.RootUser.Id); cometDirectory.SetPermission( null, "LoopbackQuality", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } if (!systemDirectory.IsFilePresent("TemplateEngine")) { systemDirectory.CreateFile( "TemplateEngine", "templateengine", FileHandlerFactoryLocator.UserFactory.RootUser.Id); systemDirectory.SetPermission( null, "TemplateEngine", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } if (!systemDirectory.IsFilePresent("JavascriptInterpreter")) { systemDirectory.CreateFile( "JavascriptInterpreter", "javascriptinterpreter", FileHandlerFactoryLocator.UserFactory.RootUser.Id); systemDirectory.SetPermission( null, "JavascriptInterpreter", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } IDirectoryHandler usersDirectory = FileHandlerFactoryLocator.FileSystemResolver.ResolveFile("Users").CastFileHandler<IDirectoryHandler>(); if (!systemDirectory.IsFilePresent("Documentation")) { systemDirectory.CreateFile( "Documentation", "documentation", FileHandlerFactoryLocator.UserFactory.RootUser.Id); systemDirectory.SetPermission( null, "Documentation", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } if (!rootDirectoryHandler.IsFilePresent("Actions")) { // Create actions directory rootDirectoryHandler.RestoreFile( "Actions", "directory", "." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Actions", FileHandlerFactoryLocator.UserFactory.RootUser.Id); rootDirectoryHandler.SetPermission( null, "Actions", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } // Let the root user see information about the anonymous user IFileContainer anonymousUserFileContainer = usersDirectory.OpenFile("anonymous.user"); usersDirectory.Chown(null, anonymousUserFileContainer.FileId, FileHandlerFactoryLocator.UserFactory.RootUser.Id); usersDirectory.RemovePermission("anonymous.user", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.AnonymousUser.Id }); if (!usersDirectory.IsFilePresent("ParticleAvatars")) { usersDirectory.CreateFile("ParticleAvatars", "directory", null); usersDirectory.SetPermission( null, "ParticleAvatars", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.LocalUsers.Id }, FilePermissionEnum.Read, true, false); } // Make sure every user has a friends group // TODO: At some point this needs to go away foreach (ID<IUserOrGroup, Guid> userId in FileHandlerFactoryLocator.UserManagerHandler.GetAllLocalUserIds()) { IUser user = FileHandlerFactoryLocator.UserManagerHandler.GetUser(userId); if (!user.BuiltIn) if (FileHandlerFactoryLocator.LocalIdentityProvider == user.IdentityProvider) { bool hasFriendsGroup = false; foreach (IGroupAndAlias group in FileHandlerFactoryLocator.UserManagerHandler.GetGroupsThatUserOwns(userId)) { if (group.Alias == "friends") hasFriendsGroup = true; } if (!hasFriendsGroup) try { FileHandlerFactoryLocator.UserManagerHandler.CreateGroup("friends", user.DisplayName + "'s friends", user.Id, GroupType.Personal); } catch (Exception e) { log.Warn("Exception creating friends group for user " + user.Name, e); } } } /*if (!rootDirectoryHandler.IsFilePresent("Config")) { IDirectoryHandler configDirectory = (IDirectoryHandler)rootDirectoryHandler.CreateFile( "Config", "directory", FileHandlerFactoryLocator.UserFactory.RootUser.Id); CreateConfigDirectory(configDirectory, "ByExtension"); CreateConfigDirectory(configDirectory, "ByType"); }*/ }
public virtual void Syncronize(IDirectoryHandler rootDirectoryHandler) { IFileHandler dir; if (rootDirectoryHandler.IsFilePresent("Actions")) { dir = rootDirectoryHandler.OpenFile("Actions").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Actions", false, DateTime.MinValue); } dir = rootDirectoryHandler.OpenFile("Shell").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Shell", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("API").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "API", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("Templates").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Templates", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("Tests").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Tests", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("Pages").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Pages", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("Docs").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Docs", false, DateTime.MinValue); dir = rootDirectoryHandler.OpenFile("Classes").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Classes", false, DateTime.MinValue); if (!rootDirectoryHandler.IsFilePresent("Config")) { dir = (IDirectoryHandler)rootDirectoryHandler.CreateFile( "Config", "directory", FileHandlerFactoryLocator.UserFactory.RootUser.Id); rootDirectoryHandler.SetPermission( null, "Config", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, ObjectCloud.Interfaces.Security.FilePermissionEnum.Read, false, false); rootDirectoryHandler.SetPermission( null, "Config", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Administrators.Id }, ObjectCloud.Interfaces.Security.FilePermissionEnum.Administer, false, false); } else dir = rootDirectoryHandler.OpenFile("Config").FileHandler; dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "Config", false, DateTime.MinValue); if (!rootDirectoryHandler.IsFilePresent("DefaultTemplate")) { dir = rootDirectoryHandler.CreateFile( "DefaultTemplate", "directory", null); rootDirectoryHandler.SetPermission( null, "DefaultTemplate", new ID<IUserOrGroup, Guid>[] { FileHandlerFactoryLocator.UserFactory.Everybody.Id }, FilePermissionEnum.Read, true, false); } else dir = rootDirectoryHandler.OpenFile("DefaultTemplate").FileHandler; /*// Only sync if the DefaultTemplate is empty List<IFileContainer> defaultTemplateFiles = new List<IFileContainer>( dir.FileContainer.CastFileHandler<IDirectoryHandler>().Files); if (defaultTemplateFiles.Count == 0) // Because most installations will modify the DefaultTemplate folder, syncing only happens if the folder is // missing. This will prevent minor system upgrades from overwriting custom look and feel. dir.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "DefaultTemplate", false);*/ dir.FileContainer.CastFileHandler<IDirectoryHandler>().SyncFromLocalDisk( "." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "DefaultTemplate", false, true); // Do not syncronize the index file; this is for the user to update. It's just a web component anyway //IFileHandler indexFile = rootDirectoryHandler.OpenFile("index.oc").FileHandler; //indexFile.SyncFromLocalDisk("." + Path.DirectorySeparatorChar + "DefaultFiles" + Path.DirectorySeparatorChar + "index.oc"); DoUpgrades(rootDirectoryHandler); }
public IFileContainer ConstructFileContainer(IFileHandler fileHandler, IFileId fileId, string typeId, IDirectoryHandler parentDirectoryHandler, FileHandlerFactoryLocator fileHandlerFactoryLocator, DateTime created) { return new FileContainer(fileHandler, fileId, typeId, parentDirectoryHandler, fileHandlerFactoryLocator, created); }
private IEnumerable<IFileContainer> GetObjectsAndTraverseDirectories(IDirectoryHandler directory) { foreach (IFileContainer toYield in directory.Files) { yield return toYield; if (toYield.FileHandler is IDirectoryHandler) foreach (IFileContainer subToYield in GetObjectsAndTraverseDirectories((IDirectoryHandler)toYield.FileHandler)) yield return subToYield; } }
public void CopyFile(IFileHandler sourceFileHandler, IFileId fileId, ID<IUserOrGroup, Guid>? ownerID, IDirectoryHandler parentDirectory) { throw new NotImplementedException("File type isn't supported"); }