/// <summary> /// Restore a document from the trash folder to its original location /// </summary> /// <param name="id">Document Id</param> public void RestoreDocument(string id) { using (var db = new ConnectDbContext(_db)) { //get all folderitems for document. should be 2 items: one doc that is deleted (IsDeleted == true) and //another document that is in the trash folder. var documentItems = db.FolderItems.Include(x => x.Folder).Where(x => x.DocumentId == id).ToList(); var ownerId = documentItems.First().Folder.OwnerId; //Get trash folder for library var trashFolder = GetTrashFolder(ownerId); foreach (var docItem in documentItems) { //if this is the doc in trash folder, then remove it if (docItem.Folder.Id == trashFolder.Id) { db.FolderItems.Remove(docItem); db.SaveChanges(); } else { //if this the document Item not in the trash folder and the IsDeleted is true, then just update the flag if (docItem.IsDeleted && docItem.Folder.Id != trashFolder.Id) { docItem.IsDeleted = false; db.FolderItems.Update(docItem); db.SaveChanges(); } } } } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ConnectDbContext context) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } app.UseAuthentication(); app.UseHttpsRedirection(); app.UseMvc(); ////seeds //if (!context.Paises.Any()) //{ // context.Paises.AddRange(new List<Pais>() { // new Pais(){ Name="Mexico", Capital="Mexico City", // Provinces = new List<Province>(){ new Province() { Name="Guerrero"}, new Province() {Name="Guanajuato" } } // }, // new Pais(){ Name="Cuba", Capital="La Habana", // Provinces = new List<Province>(){ new Province() { Name = "Venezuela" }, new Province() { Name = "Bolivia" } } // } // } ); //} //end seeds }
public async Task <IEnumerable <TDocument> > GetDeletedDocuments(string ownerId) { IEnumerable <TDocument> documents = new List <TDocument>(); var library = await GetDocumentLibraryAsync(ownerId); using (var db = new ConnectDbContext(_db)) { var deletedDocumentIds = db.FolderItems .Include(x => x.Folder) .Where(x => x.Folder.DocumentLibraryId == library.Id && x.IsDeleted) .Select(x => x.DocumentId); if (deletedDocumentIds != null) { if (deletedDocumentIds.Any()) { //HACK: Linq was puking when trying to do a correlated expression between 2 different dbContexts. // Fixing by materializing ID list to primitive array, then peferming query documents = _documentService.QueryByIds(deletedDocumentIds).ToList(); } } return(documents); } }
private async Task EnsureTrashFolderAsync(string ownerId) { var root = (Folder) await GetRootFolderAsync(ownerId); using (var db = new ConnectDbContext(_db)) { var trashFolder = db.Folders.FirstOrDefault(x => x.ParentId == root.Id && x.Title == _trashFolderName && x.IsSystemFolder); if (trashFolder == null) { var newTrashFolder = new Folder() { Id = Guid.NewGuid().ToString("N"), Title = _trashFolderName, OwnerLevel = OwnerLevel.User, DocumentType = _documentType, FolderType = typeof(Folder).Name, OwnerId = ownerId, IsSystemFolder = true, DocumentLibraryId = root.DocumentLibraryId, CreatedBy = ownerId }; await CreateFolderInternalAsync(newTrashFolder, true); } } }
public PageMasterManager(ContentManager contentManager, SiteTemplateManager templateManager, ConnectDbContext dbContext, ConnectCoreOptions coreOptions) { _db = dbContext; _contentManager = contentManager; _templateManager = templateManager; _coreOptions = coreOptions; }
/// <summary> /// Ensure a document library exist or it will create a new one based on type and owner /// </summary> /// <param name="ownerId"></param> /// <param name="libraryType"></param> /// <param name="location"></param> /// <returns>DocumentLibrary</returns> public async Task <DocumentLibrary> CreateDocumentLibrary(string ownerId, string libraryType, string location) { Ensure.NotNullOrEmpty(ownerId); Ensure.NotNullOrEmpty(libraryType); Ensure.NotNullOrEmpty(location); DocumentLibrary documentLibrary = null; using (var db = new ConnectDbContext(_db)) { documentLibrary = db.DocumentLibraries.FirstOrDefault(x => x.OwnerId == ownerId && x.LibraryType == libraryType); if (documentLibrary == null) { documentLibrary = new DocumentLibrary { Id = Guid.NewGuid().ToString("N"), OwnerId = ownerId, LibraryType = libraryType, Location = location }; db.DocumentLibraries.Add(documentLibrary); db.SaveChanges(); } } //Ensure there is a Trash folder and Root folder await EnsureTrashFolderAsync(ownerId); return(documentLibrary); }
private async Task <FolderItem> GetItemAsync(string documentId, string folderId) { using (var db = new ConnectDbContext(_db)) { return(await db.FolderItems.SingleOrDefaultAsync(x => x.FolderId == folderId && x.DocumentId == documentId)); } }
private async Task <Folder> GetFullFolderAsync(string id) { using (var db = new ConnectDbContext(_db)) { return(await db.Folders.SingleOrDefaultAsync(x => x.Id == id)); } }
public async Task <IFolder> GetRootFolderAsync(string ownerId, bool ignoreTrash = false) { Ensure.NotNullOrEmpty(ownerId); //await EnsureLibraryCreated(ownerId); await EnsureRootFolderAsync(ownerId); using (var db = new ConnectDbContext(_db)) { var result = db.Folders .Include(x => x.ChildFolders) .FirstOrDefault(x => // Prevents seeding errors from crashing startup x.DocumentType == _documentType && x.OwnerId == ownerId && x.ParentFolder == null && !x.IsDeleted ); result.ChildFolders = result.ChildFolders.Where(x => !x.IsDeleted).ToList(); if (ignoreTrash) { result.ChildFolders = result.ChildFolders.Where(x => (!x.IsSystemFolder && x.Title != _trashFolderName)).ToList(); } return(result); } }
// Because the context is now short-lived (for concurrency protection), making this now a LINQ-finalized enumerable instead of queryable private async Task <IEnumerable <FolderItem> > GetItemsAsync(string folderId) { using (var db = new ConnectDbContext(_db)) { return(await db.FolderItems.Where(x => x.FolderId == folderId && !x.IsDeleted).ToArrayAsync()); } }
public async Task AddDocumentAsync(TDocument document, IFolder folder) { Ensure.NotNull(document, $"{nameof(document)} cannot be null."); Ensure.NotNull(folder, $"{nameof(folder)} cannot be null."); var item = await GetItemAsync(document.DocumentId, folder.Id); if (item == null) { using (var db = new ConnectDbContext(_db)) { item = new FolderItem() { AllowComments = true, DocumentId = document.DocumentId, Folder = folder as Folder, FolderId = folder.Id, Id = KeyGen.NewGuid(), InheritSecurity = false, InheritSharing = false, InheritTags = false, ItemStatus = ModerationStatus.Approved }; // No async, since we are in a lock db.Entry(item).State = EntityState.Added; await db.FolderItems.AddAsync(item); db.SaveChanges(); } } }
public SitePublisher ( ConnectDbContext connectDb, ConnectCoreOptions coreOptions, IdentityDbContext identityDb, SiteTemplateManager templateManager, PageMasterManager masterPageManager, PageManager pageManager, ContentManager contentManager, ClientManager clientManager, IFolderManager <FileDocument> folderManager ) { _connectDb = connectDb; _identityDb = identityDb; _templateManager = templateManager; _contentManager = contentManager; _clientManager = clientManager; _folderManager = folderManager; _pageManager = pageManager; _masterPageManager = masterPageManager; _coreOptions = coreOptions; _defaultDataFolder = _coreOptions.FileSystemRoot + "\\data\\json\\seeddata"; }
public async Task <IEnumerable <IFolder> > GetFoldersAsync(IFolder folder, bool ignoreTrash = false) { Ensure.NotNull(folder, $"{nameof(folder)} cannot be null."); using (var db = new ConnectDbContext(_db)) { var folders = await db.Folders .Include(x => x.ChildFolders) .Where(x => x.ParentId == folder.Id && !x.IsDeleted) .OrderBy(x => x.Title) .ToListAsync(); if (ignoreTrash) { folders = folders.Where(x => !x.IsSystemFolder && x.Title != _trashFolderName).ToList(); } foreach (var fold in folders) { fold.ChildFolders = fold.ChildFolders.Where(x => !x.IsDeleted).ToList(); if (ignoreTrash) { fold.ChildFolders = fold.ChildFolders.Where(x => (!x.IsSystemFolder && x.Title != _trashFolderName)).ToList(); } } return(folders); } }
public static async Task <T> updateModel(ConnectDbContext _context, T model) { _context.Entry(model).State = EntityState.Modified; await _context.SaveChangesAsync(); return(model); }
public NavMenuPageProvider(ConnectDbContext connectDbContext, UserContext userContext, SiteContext siteContext, PageManager pageManager) { _connectDb = connectDbContext; _userContext = userContext; _siteContext = siteContext; _pageManager = pageManager; }
public UserGroupManager(ConnectDbContext connectDb, IdentityDbContext identityDb, UserContext userContext, SiteManager siteManager) { _connectDb = connectDb; _identityDb = identityDb; _userContext = userContext; _siteManager = siteManager; }
public BlogQueryService(SiteContext siteContext, BlogSecurityService blogSecurity, ConnectDbContext connectDbContext, BlogDbContext blogDbContext, IContextAccessor <UserContext> userContextAccessor) { _siteContext = siteContext; _connectDbContext = connectDbContext; _blogDbContext = blogDbContext; _blogSecurity = blogSecurity; _userContextAccessor = userContextAccessor; }
public SeedDocumentData(ConnectDbContext connectDb, string systemRoot, IFolderManager <FileDocument> folderManager, IDocumentService <FileDocument> documentService, IDocumentUploadService <FileDocument> uploadService) { _systemRoot = systemRoot; _connectDb = connectDb; _folderManager = folderManager; _documentService = documentService; _uploadService = uploadService; }
public AssignmentsWidgetConfigForm(SiteContext siteContext, ConnectDbContext db, AssignmentsWidgetService widgetService, UserContext userContext) { _siteContext = siteContext; _db = db; _widgetService = widgetService; _userContext = userContext; }
public FileDocumentService(ConnectDbContext readDb, DbContextOptions <ConnectDbContext> writeDb) { Ensure.NotNull(readDb); Ensure.NotNull(writeDb); this._readDb = readDb; this._writeDb = writeDb; }
public AnnouncementQueryService(SiteContext siteContext, AnnouncementSecurityService announcementSecurity, ConnectDbContext connectDbContext, AnnouncementDbContext announcementDbContext, IContextAccessor <UserContext> userContextAccessor) { _siteContext = siteContext; _connectDbContext = connectDbContext; _announcementDbContext = announcementDbContext; _announcementSecurity = announcementSecurity; _userContextAccessor = userContextAccessor; }
public JobMigrateConnectDb(DbLogService logger, ConnectDbContext connectDb) { _connectDb = connectDb; _logger = logger; _logger.Category = "Jobs"; _logger.ResourceId = _jobName; }
public VideoWidgetConfigForm(SiteContext siteContext, ConnectDbContext db, VideoWidgetService videoService, VideoStreamLinkService linkService, UserContext userContext) { _siteContext = siteContext; _db = db; _videoService = videoService; _linkService = linkService; _userContext = userContext; }
private async Task <int> GetTotalFolderCountAsync(string ownerId) { using (var db = new ConnectDbContext(_db)) { return(await db.Folders .Where(x => x.OwnerId == ownerId) .CountAsync()); } }
public NavMenuWidgetConfigForm(SiteContext siteContext, ConnectDbContext db, NavMenuWidgetService widgetService, UserContext userContext, NavigationMenuManager navMenuManager) { _siteContext = siteContext; _db = db; _widgetService = widgetService; _userContext = userContext; _navMenuManager = navMenuManager; }
public ContentEmbeddedTagHelper( IViewComponentHelper componentHelper, SiteContext siteContext, ConnectDbContext connectDb ) { _componentHelper = componentHelper as DefaultViewComponentHelper; _siteContext = siteContext; _connectDb = connectDb; }
public async Task <IFolder> UpdateFolderAsync(IFolder folder) { Ensure.NotNull(folder, $"{nameof(folder)} cannot be null."); using (var db = new ConnectDbContext(_db)) { db.Folders.Update(folder.ToFolder()); db.SaveChanges(); return(await db.Folders.SingleOrDefaultAsync(x => x.Id == folder.Id) ?? folder); } }
public async Task <IFolder> GetFolderAsync(TDocument document) { Ensure.NotNull(document, "Document cannot be null."); using (var db = new ConnectDbContext(_db)) { return(db.Folders .Include(x => x.ChildFolders) .FirstOrDefault(f => f.Items.Any(i => i.DocumentId == document.DocumentId))); } }
public async Task <FileDocument> UpdateAsync(FileDocument document) { using (var db = new ConnectDbContext(_writeDb)) { db.Attach(document); db.Entry(document).State = EntityState.Modified; db.SaveChanges(); } return(document); }
public UserPageComponent(PageManager pageManager, PageSecurityManager pageSecurity, PageMasterManager masterPageManager, SiteManager siteManager, IContextAccessor <UserContext> userContextAccessor, ConnectDbContext connectDbContext, IdentityDbContext identityDbContext) { _userContextAccessor = userContextAccessor; _masterPageManager = masterPageManager; _pageSecurity = pageSecurity; _pageManager = pageManager; _siteManager = siteManager; // TODO: Move logic to services _connectDbContext = connectDbContext; _identityDbContext = identityDbContext; }