/// <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;
}
