//TODO: Rename to account controller
public AccountController(IOptions <AegisOptions> openIdOptions,
IOptions <ServerOptions> serverOptions,
IOptions <DriveOptions> driveOptions,
IFolderManager <FileDocument> folderManager,
IDocumentService <FileDocument> documentService,
ILogger <AccountController> logger,
TagManager tags,
MenuProvider menuProvider,
UserGroupManager userGroupManager,
SiteContextAccessor siteContextAccessor,
UserManager userManager,
PageMasterManager masterPageManager,
UserContextAccessor userContextAccessor,
SecurityPoolManager poolManager,
GroupManager groupManager) : base(logger)
{
_oidConfig = openIdOptions.Value;
_serverOptions = serverOptions.Value;
_driveOptions = driveOptions.Value;
_tags = tags;
_menuProvider = menuProvider;
_folderManager = folderManager;
_documentService = documentService;
_userGroupManager = userGroupManager;
_userManager = userManager;
_poolManager = poolManager;
_userContextAccessor = userContextAccessor;
_siteContextAccessor = siteContextAccessor;
_masterPageManager = masterPageManager;
_groupManager = groupManager;
}
private static async Task <bool> IsTrashFolderAsync <TDocument>(this IFolderManager <TDocument> manager, IFolder folder)
where TDocument : class, IDocument
{
var root = await manager.GetRootFolderAsync(folder.OwnerId);
return(folder != null && folder.ParentId == root.Id && string.Equals("Trash", folder.Title, StringComparison.CurrentCultureIgnoreCase));
}
public HttpResponseMessage CreateThumbnail(CreateThumbnailDTO dto)
{
IFileManager _fileManager = FileManager.Instance;
IFolderManager _folderManager = FolderManager.Instance;
IFileInfo _file = _fileManager.GetFile(dto.FileId);
if (_file == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "File Not Found"));
//return Json(new {Result = "error"});
}
IFolderInfo _folder = _folderManager.GetFolder(_file.FolderId);
string ext = _file.Extension;
if (!(ext.StartsWith(".")))
{
ext = "." + ext;
}
string sizedPhoto = _file.FileName.Replace(ext, "_" + dto.Width.ToString(CultureInfo.InvariantCulture) + "x" + dto.Height.ToString(CultureInfo.InvariantCulture) + ext);
IFileInfo newPhoto = _fileManager.AddFile(_folder, sizedPhoto, _fileManager.GetFileContent(_file));
sizedPhoto = ImageUtils.CreateImage(newPhoto.PhysicalPath, dto.Height, dto.Width);
newPhoto = _fileManager.UpdateFile(newPhoto);
return(Request.CreateResponse(HttpStatusCode.OK, newPhoto.ToJson()));
}
public void DeleteRole(RoleInfo role)
{
Requires.NotNull("role", role);
AddMessage(role, EventLogController.EventLogType.ROLE_DELETED);
if (role.SecurityMode != SecurityMode.SecurityRole)
{
//remove group artifacts
var portalSettings = PortalController.GetCurrentPortalSettings();
IFileManager _fileManager = FileManager.Instance;
IFolderManager _folderManager = FolderManager.Instance;
IFolderInfo groupFolder = _folderManager.GetFolder(portalSettings.PortalId, "Groups/" + role.RoleID);
if (groupFolder != null)
{
_fileManager.DeleteFiles(_folderManager.GetFiles(groupFolder));
_folderManager.DeleteFolder(groupFolder);
}
JournalController.Instance.SoftDeleteJournalItemByGroupId(portalSettings.PortalId, role.RoleID);
}
provider.DeleteRole(role);
ClearRoleCache(role.PortalID);
}
public CompressImagesViewModel(IFolderManager folderManager, IEquipmentDetector equipmentDetector, IMessenger messenger)
{
if (folderManager == null)
{
throw new ArgumentNullException(nameof(folderManager));
}
if (equipmentDetector == null)
{
throw new ArgumentNullException(nameof(equipmentDetector));
}
_folderManager = folderManager;
_equipmentDetector = equipmentDetector;
_numberOfImages = 0;
_numberOfProcessedFiles = 0;
RenameFormat = "yyyyMMdd_hhmmss";
SelectSourceFolderCommand = new RelayCommand(SelectSourceFolderExecute);
SelectTargetFolderCommand = new RelayCommand(SelectTargetFolderExecute);
CompressImagesCommand = new RelayCommand(CompressImagesExecute, CompressImagesCanExecute);
DetectedSourceEquipmentList = new ObservableCollection <Equipment>();
messenger.Register <FolderSelectedMessage>(this, FolderSelectedMessageHandler);
}
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 SiteLibraryBrowser(IFolderManager <FileDocument> folderManager,
IContextAccessor <AdminContext> adminContextAccessor)
{
_folderManager = folderManager;
_adminContext = adminContextAccessor.GetContext();
ownerId = _adminContext?.SiteId;
}
public static async Task <IFolder> AddFolderAsync <TDocument>(this IFolderManager <TDocument> manager, string name, string ownerId, string parentId = null)
where TDocument : class, IDocument
{
Ensure.NotNullOrEmpty(name, $"{name} cannot be null or empty.");
Ensure.NotNullOrEmpty(ownerId, $"{ownerId} cannot be null or empty.");
var documentLibrary = await manager.GetDocumentLibraryAsync(ownerId);
Ensure.NotNull(documentLibrary, $"Document Library cannot be null.");
var result = new Folder()
{
DocumentType = typeof(FileDocument).FullName,
FolderType = typeof(Folder).FullName,
OwnerLevel = OwnerLevel.User,
OwnerId = ownerId,
CreatedBy = ownerId,
FolderFlags = FolderFlag.Shared,
Id = KeyGen.NewGuid(),
//ParentFolder = string.IsNullOrEmpty(parentId) ? null : (await manager.GetFolderAsync(parentId)),
ParentId = parentId,
Title = name,
DocumentLibraryId = documentLibrary.Id
};
return(await manager.CreateFolderAsync(result));
}
public LibraryDataController(
IFolderManager <FileDocument> folderManager,
IDocumentService <FileDocument> documentService,
IOptions <DriveOptions> driveOptions,
TagManager tagManager,
DbLoggerProvider log,
DbLogService logFetcher,
ILogger <LibraryDataController> logger,
ResourceManager resourceManager,
FileFolderBrowser fileFolderBrowser,
IAuthorizationService authorizationService,
IContextAccessor <AdminContext> adminContextAccessor,
IContextAccessor <SiteContext> siteContextAccessor) : base(logger)
{
_folderManager = folderManager;
_documentService = documentService;
_driveOptions = driveOptions.Value;
_tagManager = tagManager;
_log = log;
_logFetcher = logFetcher;
_resourceManager = resourceManager;
_fileFolderBrowser = fileFolderBrowser;
_authorizationService = authorizationService;
_adminContext = adminContextAccessor.GetContext();
_siteContext = siteContextAccessor.GetContext();
}
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 FolderController(IStringLocalizer <FolderController> localizer, IFolderManager folderManager, IGroupManager groupManager,
INoteManager noteManager, IEventManager eventManager)
{
_localizer = localizer;
_folderManager = folderManager;
_groupManager = groupManager;
_noteManager = noteManager;
_eventManager = eventManager;
}
private static IEnumerable<IFolderInfo> GetFolders(IFolderManager folderManager, IFolderInfo portalFolder)
{
var folders = new List<IFolderInfo>();
foreach (var item in folderManager.GetFolders(portalFolder))
{
folders.Add(item);
folders.AddRange(GetFolders(folderManager, item));
}
return folders;
}
public NoteController(INoteManager noteManager, IGroupManager groupManager, IFolderManager folderManager,
IUserNoteManager userNoteManager, IEventManager eventManager, IFileManager fileManager)
{
_noteManager = noteManager;
_userNoteManager = userNoteManager;
_groupManager = groupManager;
_folderManager = folderManager;
_eventManager = eventManager;
_fileManager = fileManager;
}
public MediaStoreService(IMediaInfoProvider mediaInfoProvider,
IMediaFileProvider mediaFileProvider,
IFolderManager manager,
IMediaFileOperationsSwitch operations)
{
_folderManager = manager;
_mediaFileProvider = mediaFileProvider;
_mediaInfoProvider = mediaInfoProvider;
_operations = operations;
}
public ClientLibraryBrowser(IFolderManager <FileDocument> folderManager,
IContextAccessor <AdminContext> adminContextAccessor,
IContextAccessor <UserContext> userContextAccessor)
{
_folderManager = folderManager;
_adminContext = adminContextAccessor.GetContext();
_userContext = userContextAccessor.GetContext();
ownerId = _adminContext?.ClientId;
}
private void Save_Click(object sender, EventArgs e)
{
if (GroupId > 0)
{
RoleController roleController = new RoleController();
Security.PortalSecurity ps = new Security.PortalSecurity();
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoScripting);
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoMarkup);
var roleInfo = roleController.GetRole(GroupId, PortalId);
if (roleInfo != null)
{
roleInfo.Description = txtDescription.Text;
roleInfo.IsPublic = rdAccessTypePublic.Checked;
if (roleInfo.Settings.ContainsKey("URL"))
{
roleInfo.Settings["URL"] = Globals.NavigateURL(TabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() });
}
else
{
roleInfo.Settings.Add("URL", Globals.NavigateURL(TabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() }));
}
if (roleInfo.Settings.ContainsKey("ReviewMembers"))
{
roleInfo.Settings["ReviewMembers"] = chkMemberApproved.Checked.ToString();
}
else
{
roleInfo.Settings.Add("ReviewMembers", chkMemberApproved.Checked.ToString());
}
TestableRoleController.Instance.UpdateRoleSettings(roleInfo, true);
roleController.UpdateRole(roleInfo);
if (inpFile.PostedFile.ContentLength > 0)
{
IFileManager _fileManager = FileManager.Instance;
IFolderManager _folderManager = FolderManager.Instance;
var rootFolderPath = PathUtils.Instance.FormatFolderPath(PortalSettings.HomeDirectory);
IFolderInfo groupFolder = _folderManager.GetFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID);
if (groupFolder == null)
{
groupFolder = _folderManager.AddFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID);
}
if (groupFolder != null)
{
var fileName = Path.GetFileName(inpFile.PostedFile.FileName);
var fileInfo = _fileManager.AddFile(groupFolder, fileName, inpFile.PostedFile.InputStream, true);
roleInfo.IconFile = "FileID=" + fileInfo.FileId;
roleController.UpdateRole(roleInfo);
}
}
}
Response.Redirect(Globals.NavigateURL(TabId, "", new String[] { "groupid=" + GroupId.ToString() }));
}
}
public static async Task <IFolder> GetTrashFolderAsync <TDocument>(this IFolderManager <TDocument> manager, string ownerId)
where TDocument : class, IDocument
{
var root = await manager.GetRootFolderAsync(ownerId);
var children = await manager.GetFoldersAsync(root);
var result = children.SingleOrDefault(x => manager.IsTrashFolderAsync(x).Result);
return(result);
}
public static async Task CopyFolderAsync(this IFolderManager <FileDocument> manager, string ownerId, string folderId, string destinationId, string newName)
{
// NOT WORKING YET (Requires Federation to work) Ensure.NotNullOrEmpty(ownerId, $"{ownerId} cannot be null or empty.");
Ensure.NotNullOrEmpty(folderId, $"{folderId} cannot be null or empty.");
Ensure.NotNullOrEmpty(destinationId, $"{destinationId} cannot be null or empty.");
var folder = await manager.GetFolderAsync(folderId);
var destination = await manager.GetFolderAsync(destinationId);
await manager.CopyFolderAsync(folder, destination, newName);
}
public void Dispose()
{
_folderParserService = null;
_folderManager = null;
_calculationService = null;
_fileReaderService = null;
_dataProcessor = null;
_outputService = null;
_fileSystem = null;
_medianManager = null;
_configService = null;
}
public FileFolderBrowser(IFolderManager <FileDocument> folderManager,
IEnumerable <ISecurityGroupProvider> groupProviders,
ISharedContent sharedContentProvider,
IDocumentService <FileDocument> documentService,
IContextAccessor <AdminContext> adminContextAccessor)
{
_folderManager = folderManager;
_groupProviders = groupProviders;
_sharedContentProvider = sharedContentProvider;
_documentService = documentService;
_adminContext = adminContextAccessor.GetContext();
}
public void DeleteRole(RoleInfo role)
{
Requires.NotNull("role", role);
AddMessage(role, EventLogController.EventLogType.ROLE_DELETED);
if (role.SecurityMode != SecurityMode.SecurityRole)
{
//remove group artifacts
var portalSettings = PortalController.Instance.GetCurrentPortalSettings();
IFileManager _fileManager = FileManager.Instance;
IFolderManager _folderManager = FolderManager.Instance;
IFolderInfo groupFolder = _folderManager.GetFolder(portalSettings.PortalId, "Groups/" + role.RoleID);
if (groupFolder != null)
{
_fileManager.DeleteFiles(_folderManager.GetFiles(groupFolder));
_folderManager.DeleteFolder(groupFolder);
}
JournalController.Instance.SoftDeleteJournalItemByGroupId(portalSettings.PortalId, role.RoleID);
}
//Get users before deleting role
var users = role.UserCount > 0 ? GetUsersByRole(role.PortalID, role.RoleName) : Enumerable.Empty <UserInfo>();
provider.DeleteRole(role);
if (RoleDeleted != null)
{
RoleDeleted(null, new RoleEventArgs()
{
Role = role
});
}
//Remove the UserInfo objects of users that have been members of the group from the cache, as they have been modified
foreach (var user in users)
{
DataCache.ClearUserCache(role.PortalID, user.Username);
}
ClearRoleCache(role.PortalID);
// queue remove role/group from search index
var document = new SearchDocumentToDelete
{
//PortalId = role.PortalID,
RoleId = role.RoleID, // this is unique and sufficient
};
DataProvider.Instance().AddSearchDeletedItems(document);
}
public JobZip(LibraryManager manager,
IDocumentService <FileDocument> docService,
IDocumentUploadService <FileDocument> ulService,
LibraryZipService zipService,
IFolderManager <FileDocument> folderManager)
{
this._manager = manager;
this._docService = docService;
this._ulService = ulService;
this._zipService = zipService;
this._folderManager = folderManager;
}
public PrivateItemsService(IUnitOfWork unitOfWork,
IMapper mapper,
IFolderManager folderManager,
IFileManager fileManager,
IConfiguration configuration)
{
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.folderManager = folderManager;
this.fileManager = fileManager;
targetPath = configuration.GetValue <string>("StoredFilesPath");
fileSizeLimit = configuration.GetValue <long>("FileSizeLimit");
}
public MediaStoreApiXmlProvider(IFolderManager manager, string xmlFileName)
{
_folderManager = manager;
_xmlFilePath = _folderManager.PathGenerator(_folderManager.MediaFolderPath, xmlFileName);
_folderManager.CreateFile(_xmlFilePath, () => {
var xDoc = new XDocument();
xDoc.Add(new XElement("files"));
xDoc.Save(_xmlFilePath);
});
_xmlRepository = XDocument.Load(_xmlFilePath);
}
public EquipmentDetector(IFolderManager folderManager, IMetaDataExtractor imageMetaDataExtractor)
{
if (folderManager == null)
{
throw new ArgumentNullException(nameof(folderManager));
}
if (imageMetaDataExtractor == null)
{
throw new ArgumentNullException(nameof(imageMetaDataExtractor));
}
_folderManager = folderManager;
_imageMetaDataExtractor = imageMetaDataExtractor;
}
public CorpClientsDataController(
SiteManager siteManager,
ClientManager clientManager,
ProductManager productManger,
Identity.SecurityPoolManager poolManager,
IFolderManager <FileDocument> folderManager,
ILogger <CorpClientsDataController> logger) : base(logger)
{
_siteManager = siteManager;
_clientManager = clientManager;
_productManger = productManger;
_poolManager = poolManager;
_folderManager = folderManager;
}
public AppLauncherTest()
{
_fileSystem = new FileSystem();
_folderParserService = new FolderParserService(_fileSystem);
_folderManager = new FolderManager(_folderParserService);
_calculationService = new CalculationService();
_fileReaderService = new FileReaderService(_fileSystem);
_dataProcessor = new DataProcessor(_calculationService, _fileReaderService);
_outputService = new ConsoleOutputService();
_medianManager = new MedianManager(_folderManager, _dataProcessor, _outputService);
_configService = new ConfigService(new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.Build());
}
public DocumentDetails(IFolderManager <FileDocument> folderManager,
IDocumentService <FileDocument> documentService,
IOptions <DriveOptions> driveOptions,
UserManager userManager,
DbLoggerProvider log)
{
Ensure.NotNull(folderManager);
Ensure.NotNull(documentService);
Ensure.NotNull(driveOptions);
this._folderManager = folderManager;
this._documentService = documentService;
this._driveOptions = driveOptions.Value;
this._log = log;
_userManager = userManager;
}
public SelectFolderViewModel(IBreadcrumbGenerator breadcrumbGenerator, IFolderManager folderManager, IMessenger messenger)
{
_breadcrumbGenerator = breadcrumbGenerator ?? throw new ArgumentNullException(nameof(breadcrumbGenerator));
_folderManager = folderManager ?? throw new ArgumentNullException(nameof(folderManager));
_messenger = messenger;
DrillDownFolderCommand = new RelayCommand <Folder>(DrillDownFolderExecuted);
NavigateBackCommand = new RelayCommand(NavigateBackExecuted, NavigateBackCanExecute);
NavigateToBreadcrumbCommand = new RelayCommand <Folder>(NavigateToBreadcrumbExecuted);
SetSelectedFolderCommand = new RelayCommand <Folder>(SetSelectedFolderExecuted);
DeselectFolderCommand = new RelayCommand(DeselectFolderExecuted);
UseFolderCommand = new RelayCommand(UseFolderExecuted);
Breadcrumbs = new ObservableCollection <Folder>();
Folders = new ObservableCollection <Folder>();
CurrentFolder = Folder.Default;
}
public static async Task <string> GetPathAsync(this IFolderManager <FileDocument> manager, IFolder folder)
{
var result = default(string);
if (folder != null)
{
result = $"/{folder.Title}";
if (!string.IsNullOrEmpty(folder.ParentId))
{
var parent = await manager.GetFolderAsync(folder.ParentId);
result = (await manager.GetPathAsync(parent)) + result;
}
}
return(result);
}
public void Setup()
{
mFactory = new Factory(new DefaultModuleConfiguration(), new ITModuleConfiguration());
mObserver = (RecordingObserver)mFactory.Build<IMessageObserver>();
mApp = mFactory.Build<IApp>();
mFile = new DotNetFile();
mRefreshToken = new RefreshTokenStore(mFile, "refreshToken.txt");
mCredentials = new CredentialStore(mFile, "credentials.txt");
var provider = new TestConfigurationProvider();
provider.SetupCredentialsFile();
provider.SetupRefreshTokenFile();
provider.SetupDummyFile();
mFileManager = new GDriveFileManager(mCredentials.Get(), mRefreshToken.Get());
new Retry(30, 125)
.WithWork(x => {
mFileManager.CleanGDriveAcct();
Assert.That(mFileManager.ListAllFilesOnRootById().ToArray(), Is.Empty);
})
.Start();
mFolderManager = new FolderManager(mCredentials.Get(), mRefreshToken.Get());
}
