public void CopyFolder(IMailFolder folder, Folder sqlEntity, bool update, string password) { try { folder.Open(FolderAccess.ReadOnly); } catch (Exception) { return; } Random rng = AzusaContext.GetInstance().RandomNumberGenerator; IList <UniqueId> uuids = folder.Search(FolderService.GetSearchQuery(sqlEntity)); foreach (UniqueId uuid in uuids) { if (MessageService.TestForMessage((int)uuid.Id)) { continue; } var message = folder.GetMessage(uuid); byte[] saltBuffer = new byte[16]; rng.NextBytes(saltBuffer); Array.Copy(azusaString, 0, saltBuffer, 0, azusaString.Length); int iterations = rng.Next(1000, short.MaxValue); Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(password, saltBuffer, iterations); Aes aes = Aes.Create(); aes.Key = deriveBytes.GetBytes(32); aes.IV = deriveBytes.GetBytes(16); MemoryStream ms = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write); message.WriteTo(cryptoStream); cryptoStream.Flush(); Mail child = new Mail(); child.Uid = (int)uuid.Id; child.MessageUtime = message.Date.DateTime.ToUnixTime(); child.Folder = sqlEntity.id; child.From = message.From[0].ToString(); if (message.To.Count > 0) { child.To = message.To[0].ToString(); } else { child.To = null; } child.Subject = message.Subject; child.Salt = saltBuffer; child.Iterations = (short)iterations; child.Data = new byte[ms.Position]; Array.Copy(ms.GetBuffer(), 0, child.Data, 0, ms.Position); MessageService.StoreMessage(child); } folder.Close(false); }
private SelectableAction[] GetActions(string path) { var actions = new List <SelectableAction> { new SelectableAction("Open", () => FolderService.OpenLocation(path)), new SelectableAction("Terminal", () => TerminalService.OpenTerminal(path)), }; var hasGit = GitService.TryGetRemoteGitLocation(path, out string uri); if (hasGit) { actions.Add(new SelectableAction("Web", () => StartProgramService.StartProgram(uri))); } foreach (var type in m_programTypesToStart) { actions.Add(new SelectableAction(type, () => StartProgramService.StartProgramOfType(type, path, true))); } foreach (var type in m_programTypesTopFolderToStart) { actions.Add(new SelectableAction(type, () => StartProgramService.StartProgramOfType(type, path, true))); } return(actions.ToArray()); }
internal static void HandleInitialData(string url, OpcInitialData initialData) { log.Debug("HandleInitialData entered"); OPCServerFolderBehaviorData folderExt = EntityCache <OPCServerFolderBehaviorData> .GetCache().AllEntities.FirstOrDefault(s => s.Url == url); Folder f = folderExt?.GetEntity() as Folder; if (f == null) { throw new Exception("No OPC server found with this URL"); } if (initialData.Nodes != null) { UpdateTagsInFolder(f.FolderID + ".tagdata", f.FolderID, url, initialData.Nodes); } string[] eventIds = FolderService.GetFolderEntities <OPCEvent>(f.FolderID).Select(e => e.Id).ToArray(); foreach (BaseTagValue value in initialData.Values) { // Record the value separately for each event, because they might update at different rates: foreach (string eventId in eventIds) { string key = eventId + "|" + value.Path; OPCEngine.mostRecentValues[key] = value; } } log.Debug("HandleInitialData complete"); }
private FolderService CreateFolderService() { var userId = Guid.Parse(User.Identity.GetUserId()); var service = new FolderService(userId); return(service); }
private void deletefolder_Click(object sender, EventArgs e) { FolderService myfolderservice = new FolderService(); myfolderservice.delete(cname); MessageBox.Show("删除文件夹成功!"); }
public AcceleratorPackage( AssortmentService assortmentService, FieldTemplateService fieldTemplateService, StructureInfoService structureInfoService, MarketService marketService, ChannelService channelService, CurrencyService currencyService, WebsiteService websiteService, InventoryService inventoryService, PriceListService priceListService, DomainNameService domainNameService, GroupService groupService, FolderService folderService, PersonService personService, LanguageService languageService, SlugifyService slugifyService) { _assortmentService = assortmentService; _fieldTemplateService = fieldTemplateService; _structureInfoService = structureInfoService; _marketService = marketService; _channelService = channelService; _currencyService = currencyService; _websiteService = websiteService; _inventoryService = inventoryService; _priceListService = priceListService; _domainNameService = domainNameService; _groupService = groupService; _folderService = folderService; _personService = personService; _languageService = languageService; _slugifyService = slugifyService; }
public Task <ConcurrentBag <SelectableItem> > GetItems() { var folders = FolderService.GetFolders(m_path); var items = folders.Select(f => new SelectableItem(m_prefix + FileService.GetFileName(f), () => GetActions(f))).ToList(); return(Task.FromResult(new ConcurrentBag <SelectableItem>(items))); }
public async void DisableDebugMode() #endif { _isDebugMode = false; SettingsService.SaveSetting(SettingsResources.DebugModeIsEnabled, false); LogService.SetLogLevel(MLogLevel.LOG_LEVEL_DEBUG); #if WINDOWS_PHONE_80 FileService.DeleteFile(AppService.GetFileLogPath()); if (App.SavedForOfflineViewModel != null) { App.SavedForOfflineViewModel.SavedForOffline.Refresh(); } #elif WINDOWS_PHONE_81 // Need force to false to show the options dialog App.AppInformation.PickerOrAsyncDialogIsOpen = false; await DialogService.ShowOptionsDialog(AppMessages.AM_SaveLogFile_Title, AppMessages.AM_SaveLogFile, new[] { new DialogButton(UiResources.Yes, () => { // Ask the user a save location FolderService.SelectFolder("SelectLogFileSaveLocation"); }), new DialogButton(UiResources.No, () => { FileService.DeleteFile(AppService.GetFileLogPath()); if (App.SavedForOfflineViewModel != null) { App.SavedForOfflineViewModel.SavedForOffline.Refresh(); } }) }); #endif }
public void Search_WithResults() { string criteria = "unit_test"; string expected = $"file_test1 : 1 occurrences {System.Environment.NewLine}"; expected += $"file_test3 : 1 occurrences {System.Environment.NewLine}"; FolderService folderService = new FolderService( host.Services.GetRequiredService <ILogger <FolderService> >()); folderService.Folder = new Folder() { Name = "folder_test", Files = new System.Collections.Generic.List <File>() }; folderService.Folder.Files.Add(new File() { Name = "file_test1", Content = "0000000unit_test0000000000000000000000000000000000000000000000000" }); folderService.Folder.Files.Add(new File() { Name = "file_test2", Content = "00000000000000000000000000000000000000000000000000000000" }); folderService.Folder.Files.Add(new File() { Name = "file_test3", Content = "0000000000000000000000000000000000000unit_test0000000000000000000" }); folderService.Search(criteria); var actual = folderService.Message; Assert.AreEqual(expected, actual, "Wrong result."); }
public async Task RemoveForOffline(AutoResetEvent waitEventRequest = null) { String parentNodePath = ((new DirectoryInfo(this.NodePath)).Parent).FullName; String sfoRootPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, AppResources.DownloadsDirectory.Replace("\\", "")); if (this.IsFolder) { await RecursiveRemoveForOffline(parentNodePath, this.Name); FolderService.DeleteFolder(this.NodePath, true); } else { // Search if the file has a pending transfer for offline and cancel it on this case TransfersService.CancelPendingNodeOfflineTransfers(this.NodePath, this.IsFolder); FileService.DeleteFile(this.NodePath); } SavedForOffline.DeleteNodeByLocalPath(this.NodePath); if (this.ParentCollection != null) { this.ParentCollection.Remove((IOfflineNode)this); } if (waitEventRequest != null) { waitEventRequest.Set(); } }
/// <summary> /// Remove the node from the offline section. /// </summary> /// <returns>TRUE if the node was successfully removed or FALSE in other case.</returns> public bool RemoveFromOffline() { var nodePath = OfflineService.GetOfflineNodePath(this.OriginalMNode); var parentNodePath = OfflineService.GetOfflineParentNodePath(this.OriginalMNode); // Search if the file has a pending transfer for offline and cancel it on this case TransferService.CancelPendingNodeOfflineTransfers(this); bool result = true; if (this.IsFolder) { result &= OfflineService.RemoveFolderFromOfflineDB(nodePath); result &= FolderService.DeleteFolder(nodePath, true); } else { result &= SavedForOfflineDB.DeleteNodeByLocalPath(nodePath); result &= FileService.DeleteFile(nodePath); } result &= OfflineService.CleanOfflineFolderNodePath(parentNodePath); this.IsSavedForOffline = !result; return(result); }
public async Task TestAddFolderTaskAsync_validParentFolder() { // Arrange var dbContext = AppDBContextMocker.GetAppDbContext(nameof(TestAddFolderTaskAsync_validParentFolder)); var fService = new FolderService(new FolderRepository(dbContext), new UnitOfWork(dbContext), null); //auto mapper configuration var mockMapper = new MapperConfiguration(cfg => { cfg.AddProfile(new ResourceToModelProfile()); cfg.AddProfile(new ModelToResourceProfile()); }); var folderModel = new SaveFolderResource() { Name = "validParentFolder", ParentFolderId = 104, }; // Act var controller = new FoldersController(fService, mockMapper.CreateMapper(), null); var response = await controller.AddFolderAsync(folderModel) as ObjectResult; dbContext.Dispose(); // Assert Assert.NotNull(response); var folderResponce = response.Value as FolderResource; Assert.NotNull(folderResponce); Assert.NotNull(folderResponce.FolderID); Assert.Equal(folderResponce.Name, folderModel.Name); Assert.Null(folderModel.ParentFolderId); }
protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); if (!NetworkService.IsNetworkAvailable()) { UpdateGUI(false); return; } if (PhoneApplicationService.Current.StartupMode == StartupMode.Activate) { // Needed on every UI interaction SdkService.MegaSdk.retryPendingConnections(); #if WINDOWS_PHONE_81 // Check to see if any folder has been picked var app = Application.Current as App; if (app != null && app.FolderPickerContinuationArgs != null) { FolderService.ContinueFolderOpenPicker(app.FolderPickerContinuationArgs, this._sharedItemsViewModel.ActiveSharedFolderView); } #endif } }
private void CheckAndUpdateOffline(MNode megaNode) { var offlineNodePath = OfflineService.GetOfflineNodePath(megaNode); if ((megaNode.getType() == MNodeType.TYPE_FILE && FileService.FileExists(offlineNodePath)) || (megaNode.getType() == MNodeType.TYPE_FOLDER && FolderService.FolderExists(offlineNodePath)) || TransferService.ExistPendingNodeOfflineTransfer(this)) { if (SavedForOfflineDB.ExistsNodeByLocalPath(offlineNodePath)) { SavedForOfflineDB.UpdateNode(megaNode); } else { SavedForOfflineDB.InsertNode(megaNode); } this.IsSavedForOffline = true; return; } if (SavedForOfflineDB.ExistsNodeByLocalPath(offlineNodePath)) { SavedForOfflineDB.DeleteNodeByLocalPath(offlineNodePath); } this.IsSavedForOffline = false; }
private async void RemoveItem(object obj) { if (await FocusedNode.RemoveAsync(false) != NodeActionResult.Cancelled) { String parentNodePath = ((new DirectoryInfo(FocusedNode.NodePath)).Parent).FullName; String sfoRootPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, AppResources.DownloadsDirectory.Replace("\\", "")); // Check if the previous folders of the path are empty and // remove from the offline and the DB on this case while (String.Compare(parentNodePath, sfoRootPath) != 0) { var folderPathToRemove = parentNodePath; parentNodePath = ((new DirectoryInfo(parentNodePath)).Parent).FullName; if (FolderService.IsEmptyFolder(folderPathToRemove)) { Deployment.Current.Dispatcher.BeginInvoke(() => GoFolderUp()); FolderService.DeleteFolder(folderPathToRemove); SavedForOffline.DeleteNodeByLocalPath(folderPathToRemove); } } Refresh(); } }
public DeploymentViewModelBuilder(ChannelService channelService, FolderService folderService, IPackage package, AuthorizationService authorizationService) { _channelService = channelService; _folderService = folderService; _package = package; _authorizationService = authorizationService; }
public FolderParser(FolderService folderService, IEnumerable <IParser> childParsers) { ChildrenParsers = new List <IParser>(); ChildrenParsers.AddRange(childParsers); ChildrenParsers.ForEach(p => p.Parent = this); this.folderService = folderService; }
/// <summary> /// Main entry point. Creates a bunch of services, and then kicks off /// the webserver, which is a blocking call (since it's the dispatcher /// thread) until the app exits. /// </summary> /// <param name="listeningPort"></param> /// <param name="args"></param> private static void StartWebServer(int listeningPort, string[] args) { try { Logging.Log("Starting Damselfly Services"); // Instantiate all of our services var status = new StatusService(); var thumbs = new ThumbnailService(); var indexing = new IndexingService(); var downloads = new DownloadService(); var basket = new BasketService(); var folder = new FolderService(); var search = new SearchService(); var tasks = new TaskService(); var config = new ConfigService(); var meta = new MetaDataService(); var wp = new WordpressService(); var proc = new ImageProcessService(); var select = new SelectionService(); Logging.Log("Starting Damselfly Webserver"); BuildWebHost(listeningPort, args).Run(); Logging.Log("Damselfly Webserver stopped. Exiting"); } catch (Exception ex) { Logging.Log("Damselfly Webserver terminated with exception: {0}", ex.Message); } }
protected override void OnNavigatedTo(NavigationEventArgs e) { if (App.AppInformation.IsStartupModeActivate) { // Needed on every UI interaction SdkService.MegaSdk.retryPendingConnections(); if (!App.AppInformation.HasPinLockIntroduced && SettingsService.LoadSetting <bool>(SettingsResources.UserPinLockIsEnabled)) { NavigateService.NavigateTo(typeof(PasswordPage), NavigationParameter.Normal, this.GetType()); return; } App.AppInformation.IsStartupModeActivate = false; #if WINDOWS_PHONE_81 // Check to see if any files have been picked var app = Application.Current as App; if (app != null && app.FolderPickerContinuationArgs != null) { FolderService.ContinueFolderOpenPicker(app.FolderPickerContinuationArgs, this._folderViewModel); } return; #endif } base.OnNavigatedTo(e); }
public MainPresenter(IMainView view, ITagView tagger, ITagService service, ICSVView csv, ISearchService searcher, FolderService folder, IStatisticsService dataset, ITaggedStatisticsService corpus, IConcordanceService concordancer, INGramService ngrammer) { this._tagger = tagger; this._service = service; this._main = view; this._csv = csv; this._searcher = searcher; this._folder = folder; this._dataset = dataset; this._corpus = corpus; this._concordancer = concordancer; this._ngrammer = ngrammer; _main.FindClick += _view_FindClick; _main.OpenIndexedCorpus += _view_OpenIndexedCorpus; _main.ConcordanceClick += _main_ConcordanceClick; _main.NGramClick += _main_NGramClick; _main.KeywordClick += _main_KeywordClick; _main.LoadStatistics += _main_LoadStatistics; _main.ExtractInfoClick += _main_ExtractInfoClick; _main.BuildIndexClick += _main_BuildIndexClick; _main.CheckNgramState += _main_CheckNgramState; _main.LoadMore += _main_LoadMore; _folder.CheckFolder(); }
public void Initialize() { var MockDb = new MockDatabase(); var P1 = new Project { ID = 4, Name = "Project1" }; MockDb.Projects.Add(P1); var P2 = new Project { ID = 2, Name = "Project2" }; MockDb.Projects.Add(P2); var F1 = new Folder { ID = 1, Name = "1Root", FolderStructure = null, ProjectStructure = P1 }; MockDb.Folders.Add(F1); var F2 = new Folder { ID = 2, Name = "11Child", FolderStructure = F1, ProjectStructure = P1 }; MockDb.Folders.Add(F2); var F3 = new Folder { ID = 3, Name = "12Child", FolderStructure = F1, //ProjectStructure = P1 }; MockDb.Folders.Add(F3); var F4 = new Folder { ID = 4, Name = "111Grandchild", FolderStructure = F2, //ProjectStructure = P1 }; MockDb.Folders.Add(F4); service = new FolderService(MockDb); }
public async Task <bool> SaveForOffline() { // User must be online to perform this operation if (!IsUserOnline()) { return(false); } MNode parentNode = SdkService.MegaSdk.getParentNode(this.OriginalMNode); String sfoRootPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, AppResources.DownloadsDirectory.Replace("\\", "")); String parentNodePath; if (ParentContainerType != ContainerType.PublicLink) { parentNodePath = Path.Combine(ApplicationData.Current.LocalFolder.Path, AppResources.DownloadsDirectory.Replace("\\", ""), (SdkService.MegaSdk.getNodePath(parentNode)).Remove(0, 1).Replace("/", "\\")); } else { // If is a public node (link) the destination folder is the SFO root parentNodePath = sfoRootPath; } if (!FolderService.FolderExists(parentNodePath)) { FolderService.CreateFolder(parentNodePath); } if (this.IsFolder) { await RecursiveSaveForOffline(parentNodePath, this); } else { await SaveFileForOffline(parentNodePath, this); } this.IsAvailableOffline = this.IsSelectedForOffline = true; // Check and add to the DB if necessary the previous folders of the path while (String.Compare(parentNodePath, sfoRootPath) != 0) { var folderPathToAdd = parentNodePath; parentNodePath = ((new DirectoryInfo(parentNodePath)).Parent).FullName; if (!SavedForOffline.ExistsNodeByLocalPath(folderPathToAdd)) { SavedForOffline.Insert(parentNode); } parentNode = SdkService.MegaSdk.getParentNode(parentNode); } return(true); }
private void SelectDownloadLocation(object obj) { if (App.FileOpenOrFolderPickerOpenend) { return; } FolderService.SelectFolder("SelectDefaultDownloadFolder"); }
public ViewModelLocator() { //ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default); IFolderService folderService = new FolderService(); string org = "test"; this.MainVM = new MainVM(folderService, org); }
public async Task RenameFolder_FolderRenamed() { var db = CreateAndSeedDb(); var service = new FolderService(db); await service.RenameFolderAsync("895973FB-F8E1-4FD6-89C4-DC13CED4780E", 1, "New Folder"); Assert.Contains(db.Folders, folder => folder.Id == 1 && folder.Name == "New Folder"); }
public async Task DeleteFolder_FolderDeleted() { var db = CreateAndSeedDb(); var service = new FolderService(db); await service.DeleteFolderAsync("895973FB-F8E1-4FD6-89C4-DC13CED4780E", 1); Assert.DoesNotContain(db.Folders, folder => folder.Id == 1); }
protected override async Task OnInitializedAsync() { _folders = await FolderService.GetFoldersAsync(ModuleState.SiteId); if (PageState.QueryString.ContainsKey("id")) { _folderId = int.Parse(PageState.QueryString["id"]); } }
private void toolStripMenuItem3_Click(object sender, EventArgs e) { folderdisplay.Items.Clear(); FolderService myFolderservice = new FolderService(); for (int i = 0; i < myFolderservice.find().Count; i++) { folderdisplay.Items.Add(myFolderservice.find()[i].Foldername, 1); } }
public async Task DeleteFolder_UserHasNoRights_ExceptionThrown() { var db = CreateAndSeedDb(); var service = new FolderService(db); await Assert.ThrowsAsync <AccessDeniedException>(async() => { await service.DeleteFolderAsync("895973FB-F8E1-4FD6-89C4-DC13CED4780E", 2); }); }
public async Task DeleteFolder_FolderDoesNotExist_ExceptionThrown() { var db = CreateAndSeedDb(); var service = new FolderService(db); await Assert.ThrowsAsync <ResourceNotFoundException>(async() => { await service.DeleteFolderAsync("895973FB-F8E1-4FD6-89C4-DC13CED4780E", 4); }); }
public FolderServiceFacts() { Database = new Db(); Database.SetupDatabase(); FolderService = new FolderService(Database.ConnectionFactory); }