private void RenameFiles(IFolderInfo folder, string newFolderPath)
{
var files = FolderManager.Instance.GetFiles(folder);
foreach (var file in files)
{
file.Folder = newFolderPath;
FileManager.Instance.UpdateFile(file);
}
}
public override string[] GetFiles(IFolderInfo folder)
{
Requires.NotNull("folder", folder);
var fileNames = DirectoryWrapper.Instance.GetFiles(folder.PhysicalPath);
for (var i = 0; i < fileNames.Length; i++)
{
var fileName = Path.GetFileName(fileNames[i]);
if (!fileName.EndsWith(ProtectedExtension, StringComparison.InvariantCultureIgnoreCase))
{
var destFileName = fileNames[i] + ProtectedExtension;
if (FileWrapper.Instance.Exists(destFileName))
FileWrapper.Instance.Delete(destFileName);
FileWrapper.Instance.Move(fileNames[i], destFileName);
}
else
{
fileName = fileName.Substring(0, fileName.LastIndexOf(ProtectedExtension, StringComparison.InvariantCultureIgnoreCase));
}
fileNames[i] = fileName;
}
return fileNames;
}
private static string CreateFile(IFolderInfo folder, string fileName, string contentType, Stream fileContent, bool unzip, bool overwrite, bool checkPermissions)
{
var strMessage = "";
var fileManager = FileManager.Instance;
try
{
var file = fileManager.AddFile(folder, fileName, fileContent, overwrite, checkPermissions, contentType);
if (unzip && file.Extension == "zip")
{
fileManager.UnzipFile(file, folder);
}
}
catch (PermissionsNotMetException)
{
strMessage += "<br />" + string.Format(Localization.GetString("InsufficientFolderPermission"), folder.FolderPath);
}
catch (NoSpaceAvailableException)
{
strMessage += "<br />" + string.Format(Localization.GetString("DiskSpaceExceeded"), fileName);
}
catch (InvalidFileExtensionException)
{
strMessage += "<br />" + string.Format(Localization.GetString("RestrictedFileType"), fileName, Host.AllowedExtensionWhitelist.ToDisplayString());
}
catch (Exception ex)
{
DnnLog.Error(ex);
strMessage += "<br />" + string.Format(Localization.GetString("SaveFileError"), fileName);
}
return strMessage;
}
/// <summary>
/// Get the folder specified in App.Settings (BasePath) combined with the module's ID
/// Will create the folder if it does not exist
/// </summary>
private IFolderInfo Folder(Guid entityGuid, string fieldName)
{
if (_folder == null)
{
var folderManager = FolderManager.Instance;
var basePath = AdamAppRootFolder.Replace("[AppFolder]", App.Folder);
var path = AdamFolderMask
.Replace("[AppFolder]", App.Folder)
.Replace("[Guid22]", GuidHelpers.Compress22(entityGuid))
.Replace("[FieldName]", fieldName);
// create all folders to ensure they exist. Must do one-by-one because dnn must have it in the catalog
var pathParts = path.Split('/');
var pathToCheck = ""; // pathParts[0];
for (var i = 0; i < pathParts.Length; i++) {
pathToCheck += pathParts[i] + "/";
if (!folderManager.FolderExists(Dnn.Portal.PortalId, pathToCheck))
folderManager.AddFolder(Dnn.Portal.PortalId, pathToCheck);
}
_folder = folderManager.GetFolder(Dnn.Portal.PortalId, path);
}
return _folder;
}
private void AddFolder(IFolderInfo fldr)
{
_folderIds.Add(fldr.FolderID); // track of the folder
AddFilesInFolder(fldr); // keep track of the files
foreach (var f in _fldm.GetFolders(fldr)) // then add subfolders
AddFolder(f);
}
public override void AddFile(IFolderInfo folder, string fileName, Stream content)
{
Requires.NotNull("folder", folder);
Requires.NotNullOrEmpty("fileName", fileName);
Requires.NotNull("content", content);
UpdateFile(folder, fileName, content);
}
private void MoveFolders(IFolderInfo folder, string newFolderPath)
{
var folderInfos = FolderManager.Instance.GetFolders(folder.PortalID).Where(f => f.FolderPath != string.Empty && f.FolderPath.StartsWith(folder.FolderPath)).ToList();
foreach (var folderInfo in folderInfos)
{
var folderPath = newFolderPath + folderInfo.FolderPath.Substring(folder.FolderPath.Length);
MoveFolder(folderPath, folderInfo);
}
}
public static IEnumerable<IFolderInfo> GetFolderHierarchy(IFolderInfo folderInfo)
{
List<IFolderInfo> res = new List<IFolderInfo>();
while (folderInfo != null && folderInfo.Id != ""){
res.Add(folderInfo);
folderInfo = (folderInfo as FolderInfo).GetParent(instance.baseDir);
}
res.Reverse();
return res;
}
public AdamItem(IFolderInfo original)
{
IsFolder = true;
Id = original.FolderID;
ParentId = original.ParentID;
Path = original.DisplayPath;
Name = original.DisplayName;
Size = 0;
Type = "folder";
}
public IFolderInfo MoveFolder(IFolderInfo folder, string newFolderPath)
{
Requires.NotNull("folder", folder);
Requires.NotNullOrEmpty("newFolderPath", newFolderPath);
newFolderPath = PathUtils.Instance.FormatFolderPath(newFolderPath);
if (folder.FolderPath == newFolderPath) return folder;
MoveFolders(folder, newFolderPath);
return FolderManager.Instance.GetFolder(folder.FolderID);
}
public static void checkFolderPermissions(int PortalId, IFolderInfo theFolder, int theUserId, List<UserInfo> approvers)
{
// Get the write permission
PermissionController pc = new PermissionController();
PermissionInfo w = (PermissionInfo)pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "WRITE")[0];
// Get a list of all the folderPermissions we currently have
FolderPermissionCollection folderPermissions = theFolder.FolderPermissions;
// Set up the first permission
FolderPermissionInfo permission = new FolderPermissionInfo();
// Set up some default values for the permission
initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID);
// Set the user id to be this user
permission.UserID = theUserId;
// Add folder permissions, with a check for duplicates.
// This duplicate check (the 'True' parameter) will classify this as a "duplicate" if this permission
// has the same PermissionID, UserID, and RoleID as a pre-existing one, and not add it if it is a duplicate
folderPermissions.Add(permission, true);
// Get all the possible approvers for this reimbursement
try
{
foreach (var approver in approvers)
{
// Create a new permission for this approver
permission = new FolderPermissionInfo();
// Initialize all the variables
initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID);
// Set the userid to the approver's id
permission.UserID = approver.UserID;
// Add permission for approver
folderPermissions.Add(permission, true);
}
}
catch { }
// Finally, add permissions for the accounts team:
try
{
permission = new FolderPermissionInfo();
// Initialize new folder permission
initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID);
// Set the role ID
DotNetNuke.Security.Roles.RoleController rc = new DotNetNuke.Security.Roles.RoleController();
permission.RoleID = rc.GetRoleByName(PortalId, "Accounts Team").RoleID;
folderPermissions.Add(permission, true);
}
catch { }
// Once we're finished adding these folder permissions, save it all
FolderPermissionController.SaveFolderPermissions(theFolder);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
ServicesFramework.Instance.RequestAjaxScriptSupport();
ServicesFramework.Instance.RequestAjaxAntiForgerySupport();
DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "oc_websiteRoot", HostingEnvironment.ApplicationVirtualPath, true);
if (System.IO.File.Exists(Server.MapPath("~/Providers/HtmlEditorProviders/CKEditor/ckeditor.js")))
{
ClientResourceManager.RegisterScript(Page, "~/Providers/HtmlEditorProviders/CKEditor/ckeditor.js", FileOrder.Js.DefaultPriority);
DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "PortalId", PortalId.ToString(), true);
CKDNNporid.Value = PortalId.ToString();
}
var folderId = Convert.ToInt32(Request.Params["FolderId"]);
Folder = FolderManager.Instance.GetFolder(folderId);
}
// ReSharper disable LoopCanBeConvertedToQuery
private List<Item> GetChildren(IFolderInfo folder, ICollection<string> extensions)
{
var everything = new List<Item>();
var folders = _folderManager.GetFolders(folder);
foreach (var currentFolder in folders)
{
everything.Add(new Item
{
id = currentFolder.FolderID,
name = currentFolder.DisplayName ?? currentFolder.FolderName,
folder = true,
parentId = folder.FolderID,
children = GetChildren(currentFolder, extensions)
});
}
var files = _folderManager.GetFiles(folder);
foreach (var file in files)
{
// list is empty or contains the file extension in question
if (extensions.Count == 0 || extensions.Contains(file.Extension.ToLowerInvariant()))
{
everything.Add(new Item
{
id = file.FileId,
name = file.FileName,
folder = false,
parentId = file.FolderId,
thumb_url = GetThumbUrl(file),
type = GetTypeName(file),
size = GetFileSize(file.Size),
modified = GetModifiedTime(file.LastModificationTime)
});
}
}
return everything;
}
public override string[] GetFiles(IFolderInfo folder)
{
Requires.NotNull("folder", folder);
var fileNames = DirectoryWrapper.Instance.GetFiles(folder.PhysicalPath);
for (var i = 0; i < fileNames.Length; i++)
{
var fileName = Path.GetFileName(fileNames[i]);
if(!fileName.EndsWith(ProtectedExtension))
{
FileWrapper.Instance.Move(fileNames[i], fileNames[i] + ProtectedExtension);
}
else
{
fileName = fileName.Substring(0, fileName.LastIndexOf(ProtectedExtension));
}
fileNames[i] = fileName;
}
return fileNames;
}
private List<Field> GetFolderPreviewFields(IFolderInfo folder)
{
var fields = new List<Field>
{
GetFolderSizeField(folder),
GetTotalFilesField(folder)
};
fields.AddRange(GetAuditFields((FolderInfo)folder, folder.PortalID));
return fields;
}
private Field GetTotalFilesField(IFolderInfo folder)
{
var field = new Field(DefaultMetadataNames.TotalFiles);
field.DisplayName = LocalizationHelper.GetString("Field" + field.Name + ".DisplayName");
var totalFiles = Convert.ToInt32(FolderManager.Instance.GetFiles(folder, true, false).Count());
field.Type = totalFiles.GetType();
field.Value = totalFiles;
field.StringValue = field.Value.ToString();
return field;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// SaveFolderPermissions updates a Folder's permissions
/// </summary>
/// <param name="folder">The Folder to update</param>
/// <history>
/// [cnurse] 04/15/2009 Created
/// </history>
/// -----------------------------------------------------------------------------
public virtual void SaveFolderPermissions(IFolderInfo folder)
{
if ((folder.FolderPermissions != null))
{
FolderPermissionCollection folderPermissions = GetFolderPermissionsCollectionByFolder(folder.PortalID, folder.FolderPath);
//Ensure that if role/user has been given a permission that is not Read/Browse then they also need Read/Browse
var permController = new PermissionController();
ArrayList permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "READ");
PermissionInfo readPerm = null;
if (permArray.Count == 1)
{
readPerm = permArray[0] as PermissionInfo;
}
PermissionInfo browsePerm = null;
permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "BROWSE");
if (permArray.Count == 1)
{
browsePerm = permArray[0] as PermissionInfo;
}
var additionalPermissions = new FolderPermissionCollection();
foreach (FolderPermissionInfo folderPermission in folder.FolderPermissions)
{
if (folderPermission.PermissionKey != "BROWSE" && folderPermission.PermissionKey != "READ" && folderPermission.AllowAccess)
{
//Try to add Read permission
var newFolderPerm = new FolderPermissionInfo(readPerm)
{
FolderID = folderPermission.FolderID,
RoleID = folderPermission.RoleID,
UserID = folderPermission.UserID,
AllowAccess = true
};
additionalPermissions.Add(newFolderPerm);
//Try to add Browse permission
newFolderPerm = new FolderPermissionInfo(browsePerm)
{
FolderID = folderPermission.FolderID,
RoleID = folderPermission.RoleID,
UserID = folderPermission.UserID,
AllowAccess = true
};
additionalPermissions.Add(newFolderPerm);
}
}
foreach (FolderPermissionInfo folderPermission in additionalPermissions)
{
folder.FolderPermissions.Add(folderPermission, true);
}
if (!folderPermissions.CompareTo(folder.FolderPermissions))
{
dataProvider.DeleteFolderPermissionsByFolderPath(folder.PortalID, folder.FolderPath);
foreach (FolderPermissionInfo folderPermission in folder.FolderPermissions)
{
dataProvider.AddFolderPermission(folder.FolderID,
folderPermission.PermissionID,
folderPermission.RoleID,
folderPermission.AllowAccess,
folderPermission.UserID,
UserController.GetCurrentUserInfo().UserID);
}
}
}
}
public override void RenameFolder(IFolderInfo folder, string newFolderName)
{
// The folder has already been moved in filesystem
}
private string ExportModule(int moduleID, string fileName, IFolderInfo folder)
{
var strMessage = "";
if (Module != null)
{
if (!String.IsNullOrEmpty(Module.DesktopModule.BusinessControllerClass) && Module.DesktopModule.IsPortable)
{
try
{
var objObject = Reflection.CreateObject(Module.DesktopModule.BusinessControllerClass, Module.DesktopModule.BusinessControllerClass);
//Double-check
if (objObject is IPortable)
{
var content = Convert.ToString(((IPortable)objObject).ExportModule(moduleID));
if (!String.IsNullOrEmpty(content))
{
//remove invalid chars in content
content = Regex.Replace(content, _invalidCharsRegex, string.Empty);
//add attributes to XML document
content = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + "<content type=\"" + CleanName(Module.DesktopModule.ModuleName) + "\" version=\"" +
Module.DesktopModule.Version + "\">" + content + "</content>";
//First check the Portal limits will not be exceeded (this is approximate)
var objPortalController = new PortalController();
var strFile = PortalSettings.HomeDirectoryMapPath + folder.FolderPath + fileName;
if (objPortalController.HasSpaceAvailable(PortalId, content.Length))
{
//add file to Files table
using (var fileContent = new MemoryStream(Encoding.UTF8.GetBytes(content)))
{
FileManager.Instance.AddFile(folder, fileName, fileContent, true, true, "application/octet-stream");
}
}
else
{
strMessage += "<br>" + string.Format(Localization.GetString("DiskSpaceExceeded"), strFile);
}
}
else
{
strMessage = Localization.GetString("NoContent", LocalResourceFile);
}
}
else
{
strMessage = Localization.GetString("ExportNotSupported", LocalResourceFile);
}
}
catch
{
strMessage = Localization.GetString("Error", LocalResourceFile);
}
}
else
{
strMessage = Localization.GetString("ExportNotSupported", LocalResourceFile);
}
}
return strMessage;
}
protected virtual ItemViewModel GetItemViewModel(IFolderInfo folder)
{
var parentFolderId = Null.NullInteger;
var parentFolderPath = string.Empty;
var parentFolder = FolderManager.Instance.GetFolder(folder.ParentID);
if (parentFolder != null)
{
parentFolderId = parentFolder.FolderID;
parentFolderPath = parentFolder.FolderPath;
}
return new ItemViewModel
{
IsFolder = true,
ItemID = folder.FolderID,
ItemName = folder.FolderName,
LastModifiedOnDate = folder.LastModifiedOnDate.ToString("g"),
PortalID = folder.PortalID,
IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID),
Permissions = GetPermissionViewModelCollection(folder),
ParentFolderID = parentFolderId,
ParentFolder = parentFolderPath,
FolderMappingID = folder.FolderMappingID,
UnlinkAllowedStatus = GetUnlinkAllowedStatus(folder)
};
}
public Export(AdamManager adm)
{
_manager = adm;
_root = _manager.Root;
}
public bool CanViewFolder(IFolderInfo folder)
{
return(FolderPermissionController.CanViewFolder((FolderInfo)folder));
}
private void Save_Click(object sender, EventArgs e)
{
if (GroupId > 0)
{
Security.PortalSecurity ps = Security.PortalSecurity.Instance;
txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoScripting);
txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoMarkup);
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoScripting);
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoMarkup);
var roleInfo = RoleController.Instance.GetRoleById(PortalId, GroupId);
if (roleInfo != null)
{
if (txtGroupName.Visible) //if this is visible assume that we're editing the groupname
{
if (txtGroupName.Text != roleInfo.RoleName)
{
if (RoleController.Instance.GetRoleByName(PortalId, txtGroupName.Text) != null)
{
lblInvalidGroupName.Visible = true;
return;
}
}
}
if (!roleInfo.IsSystemRole)
{
roleInfo.RoleName = txtGroupName.Text;
}
roleInfo.Description = txtDescription.Text;
roleInfo.IsPublic = rdAccessTypePublic.Checked;
if (roleInfo.Settings.ContainsKey("ReviewMembers"))
{
roleInfo.Settings["ReviewMembers"] = chkMemberApproved.Checked.ToString();
}
else
{
roleInfo.Settings.Add("ReviewMembers", chkMemberApproved.Checked.ToString());
}
RoleController.Instance.UpdateRoleSettings(roleInfo, true);
RoleController.Instance.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.Instance.UpdateRole(roleInfo);
}
}
//Clear Roles Cache
DataCache.RemoveCache("GetRoles");
}
Response.Redirect(_navigationManager.NavigateURL(TabId, "", new String[] { "groupid=" + GroupId.ToString() }));
}
}
private bool IsAccessibleByUser(IFolderInfo folder)
{
return(FolderPermissionController.Instance.CanAddFolder(folder));
}
public bool HasFolderPermission(IFolderInfo folder, string permissionKey)
{
return(UserController.Instance.GetCurrentUserInfo().IsSuperUser ||
FolderPermissionController.HasFolderPermission(folder.FolderPermissions, permissionKey));
}
private IFileInfo CreateGroupIconImage(IFileInfo groupIcon)
{
// determine the new width
var intNewWidth = 124;
if (groupIcon.Width <= intNewWidth)
{
intNewWidth = groupIcon.Width;
}
// determine the new height (aspect ratio from width)
var intNewHeight = (int)(groupIcon.Height * intNewWidth / groupIcon.Width);
if (intNewHeight > MAX_IMAGE_HEIGHT)
{
intNewWidth = (int)(groupIcon.Width * MAX_IMAGE_HEIGHT / groupIcon.Height);
intNewHeight = MAX_IMAGE_HEIGHT;
}
Image oImage = null;
try
{
// get an instance of the image from the file system
oImage = Image.FromStream(FileManager.Instance.GetFileContent(groupIcon));
}
catch (Exception ex)
{
Exceptions.LogException(ex);
}
if (oImage == null)
{
throw new NullReferenceException("The image could not be loaded from the file system.");
}
// create and save a thumbnail
Image oThumbnail;
// use the built-in thumbnail generation method
//oThumbnail = oImage.GetThumbnailImage(intNewWidth, intNewHeight, ThumbnailCallback, IntPtr.Zero);
oThumbnail = CreateThumbnailImage(oImage, intNewWidth, intNewHeight);
// save the image in memory
var ms = new MemoryStream();
// branch the save statement to avoid encoder errors
switch (groupIcon.Extension.ToLower())
{
case "jpg":
oThumbnail.Save(ms, ImageFormat.Jpeg);
break;
case "gif":
oThumbnail.Save(ms, ImageFormat.Gif);
break;
case "png":
oThumbnail.Save(ms, ImageFormat.Png);
break;
default:
throw new InvalidCastException("The image file is not in a supported format.");
}
// get an instance of the DNN folder
IFolderInfo folder = FolderManager.Instance.GetFolder(PortalId, groupIcon.Folder);
// generate a thumbnail name
var thumbnailName = GetThumbnailName(groupIcon.FileName, false);
// save the image in the DNN file system
var newFile = FileManager.Instance.AddFile(folder, thumbnailName, ms);
// return the new thumbnail image to the calling method
return(newFile);
}
public virtual PreviewInfoViewModel GetFolderPreviewInfo(IFolderInfo folder)
{
return new PreviewInfoViewModel
{
Title = LocalizationHelper.GetString("PreviewPanelTitle.Text"),
ItemId = folder.FolderID,
IsFolder = true,
PreviewImageUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID),
Fields = GetFolderPreviewFields(folder)
};
}
/// <summary>
/// Set Folder Permission
/// </summary>
/// <param name="folderInfo">The folder info.</param>
private void SetFolderPermission(IFolderInfo folderInfo)
{
FolderManager.Instance.CopyParentFolderPermissions(folderInfo);
}
protected ItemPathViewModel GetItemPathViewModel(IFolderInfo folder)
{
return new ItemPathViewModel
{
IsFolder = true,
ItemID = folder.FolderID,
DisplayPath = folder.DisplayPath,
IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID)
};
}
/// <summary> /// Renames the specified folder using the new foldername. /// </summary> public abstract void RenameFolder(IFolderInfo folder, string newFolderName);
/// <summary>
/// Fill the Folder TreeView with all (Sub)Directories
/// </summary>
/// <param name="currentFolderInfo">The current folder information.</param>
private void FillFolderTree(IFolderInfo currentFolderInfo)
{
this.FoldersTree.Nodes.Clear();
DirectoryInfo dirInfo = new DirectoryInfo(currentFolderInfo.PhysicalPath);
RadTreeNode folderNode = new RadTreeNode
{
Text = dirInfo.Name,
Value = dirInfo.FullName,
ImageUrl = "Images/folder.gif",
ExpandedImageUrl = "Images/folderOpen.gif"
};
switch (this.GetStorageLocationType(currentFolderInfo.PhysicalPath))
{
case FolderController.StorageLocationTypes.SecureFileSystem:
{
folderNode.ImageUrl = "Images/folderLocked.gif";
folderNode.ExpandedImageUrl = "Images/folderOpenLocked.gif";
}
break;
case FolderController.StorageLocationTypes.DatabaseSecure:
{
folderNode.ImageUrl = "Images/folderdb.gif";
folderNode.ExpandedImageUrl = "Images/folderdb.gif";
}
break;
}
this.FoldersTree.Nodes.Add(folderNode);
var folders = FolderManager.Instance.GetFolders(currentFolderInfo);
foreach (RadTreeNode node in
folders.Cast<FolderInfo>().Select(this.RenderFolder).Where(node => node != null))
{
switch (this.GetStorageLocationType(Convert.ToInt32(node.ToolTip)))
{
case FolderController.StorageLocationTypes.SecureFileSystem:
{
node.ImageUrl = "Images/folderLocked.gif";
node.ExpandedImageUrl = "Images/folderOpenLocked.gif";
}
break;
case FolderController.StorageLocationTypes.DatabaseSecure:
{
node.ImageUrl = "Images/folderdb.gif";
node.ExpandedImageUrl = "Images/folderdb.gif";
}
break;
}
folderNode.Nodes.Add(node);
}
}
private void MoveFolder(string folderPath, IFolderInfo folderInfo)
{
RenameFiles(folderInfo, folderPath);
folderInfo.FolderPath = folderPath;
FolderManager.Instance.UpdateFolder(folderInfo);
}
/// <summary>
/// Shows the files in directory.
/// </summary>
/// <param name="currentFolderInfo">The current folder information.</param>
/// <param name="pagerChanged">if set to <c>true</c> [pager changed].</param>
private void ShowFilesIn(IFolderInfo currentFolderInfo, bool pagerChanged = false)
{
this.CheckFolderAccess(currentFolderInfo.FolderID, false);
if (!pagerChanged)
{
this.FilesTable = this.GetFiles(currentFolderInfo);
this.GetDiskSpaceUsed();
}
else
{
if (this.FilesTable == null)
{
this.FilesTable = this.GetFiles(currentFolderInfo);
}
}
var filesPagedDataSource = new PagedDataSource { DataSource = this.FilesTable.DefaultView };
if (this.currentSettings.FileListPageSize > 0)
{
filesPagedDataSource.AllowPaging = true;
filesPagedDataSource.PageSize = this.currentSettings.FileListPageSize;
filesPagedDataSource.CurrentPageIndex = pagerChanged ? this.PagerFileLinks.CurrentPageIndex : 0;
}
this.PagerFileLinks.PageCount = filesPagedDataSource.PageCount;
this.PagerFileLinks.RessourceFile = this.ResXFile;
this.PagerFileLinks.LanguageCode = this.LanguageCode;
this.PagerFileLinks.Visible = filesPagedDataSource.PageCount > 1;
// this.FilesList.DataSource = this.GetFiles(directory);
this.FilesList.DataSource = filesPagedDataSource;
this.FilesList.DataBind();
}
protected abstract void DeleteFolderInternal(FolderMappingInfo folderMapping, IFolderInfo folder);
/// <summary> /// Gets a file Stream of the specified file. /// </summary> public abstract Stream GetFileStream(IFolderInfo folder, string fileName);
public bool IsFolderVersioned(IFolderInfo folder)
{
return(IsFileVersionEnabled(folder.PortalID) && folder.IsVersioned);
}
/// <summary>
/// Get actual path to a file in specified folder
/// </summary>
/// <param name="folder">The folder that contains the file</param>
/// <param name="fileName">The file name</param>
/// <returns>A windows supported path to the file</returns>
protected virtual string GetActualPath(IFolderInfo folder, string fileName)
{
return(Path.Combine(folder.PhysicalPath, fileName));
}
private Stream GetVersionContent(FolderProvider provider, IFolderInfo folder, IFileInfo file, int version)
{
return(provider.GetFileStream(folder, file, version));
}
public override Stream GetFileStream(IFolderInfo folder, string fileName)
{
Requires.NotNull("folder", folder);
Requires.NotNullOrEmpty("fileName", fileName);
return(GetFileStreamInternal(GetActualPath(folder, fileName)));
}
/// <remarks>
/// No implementation needed
/// </remarks>
public override void DeleteFolder(IFolderInfo folder)
{
}
public override string[] GetFiles(IFolderInfo folder)
{
Requires.NotNull("folder", folder);
return(FolderManager.Instance.GetFiles(folder).Select(file => file.FileName).ToArray());
}
public override Stream GetFileStream(IFolderInfo folder, IFileInfo file, int version)
{
Requires.NotNull("file", file);
return(file != null?GetFileStreamInternal(DataProvider.Instance().GetFileVersionContent(file.FileId, version)) : null);
}
private Field GetFolderSizeField(IFolderInfo folder)
{
var field = new Field(DefaultMetadataNames.Size);
var size = FolderManager.Instance.GetFiles(folder, true, false).Sum(f => (long)f.Size);
field.DisplayName = LocalizationHelper.GetString("Field" + field.Name + ".DisplayName");
field.Type = size.GetType();
field.Value = size;
field.StringValue = string.Format(new FileSizeFormatProvider(), "{0:fs}", size);
return field;
}
public override void MoveFile(IFileInfo file, IFolderInfo destinationFolder)
{
}
private string GetUnlinkAllowedStatus(IFolderInfo folder)
{
if (AreMappedPathsSupported(folder.FolderMappingID) && folder.ParentID > 0 && GetFolder(folder.ParentID).FolderMappingID != folder.FolderMappingID)
{
return "onlyUnlink";
}
if (AreMappedPathsSupported(folder.FolderMappingID))
{
return "true";
}
return "false";
}
public override void RenameFolder(IFolderInfo folder, string newFolderName)
{
}
public bool HasPermission(IFolderInfo folder, string permissionKey)
{
var hasPermision = PortalSettings.Current.UserInfo.IsSuperUser;
if (!hasPermision && folder != null)
{
hasPermision = FolderPermissionController.HasFolderPermission(folder.FolderPermissions, permissionKey);
}
return hasPermision;
}
/// <summary>
/// Get actual path to a folder
/// </summary>
/// <param name="folder">The folder</param>
/// <returns>A windows supported path to the folder</returns>
protected virtual string GetActualPath(IFolderInfo folder)
{
return(folder.PhysicalPath);
}
protected virtual FolderViewModel GetFolderViewModel(IFolderInfo folder)
{
var folderName = string.IsNullOrEmpty(folder.FolderName)
? LocalizationHelper.GetString("RootFolder.Text")
: folder.FolderName;
var folderViewModel = new FolderViewModel
{
FolderID = folder.FolderID,
FolderMappingID = folder.FolderMappingID,
FolderName = folderName,
FolderPath = folder.FolderPath,
PortalID = folder.PortalID,
LastModifiedOnDate = folder.LastModifiedOnDate.ToString("g"),
IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID),
Permissions = GetPermissionViewModelCollection(folder),
HasChildren = folder.HasChildren
};
folderViewModel.Attributes.Add(new KeyValuePair<string, object>("UnlinkAllowedStatus", GetUnlinkAllowedStatus(folder)));
return folderViewModel;
}
/// <summary>
/// Moves a file to a new folder.
/// </summary>
/// <param name="file"></param>
public virtual void MoveFile(IFileInfo file, IFolderInfo destinationFolder)
{
throw new NotImplementedException("This provider does not implement MoveFile");
}
private IEnumerable<PermissionViewModel> GetPermissionViewModelCollection(IFolderInfo folder)
{
// TODO Split permission between CE and PE packages
string[] permissionKeys = { "ADD", "BROWSE", "COPY", "READ", "WRITE", "DELETE", "MANAGE", "VIEW", "FULLCONTROL" };
return permissionKeys.Select(permissionKey => new PermissionViewModel { Key = permissionKey, Value = HasPermission(folder, permissionKey) }).ToList();
}
/// <summary> /// Adds a new file to the specified folder. /// </summary> /// <remarks> /// Do not close content Stream. /// </remarks> public abstract void AddFile(IFolderInfo folder, string fileName, Stream content);
/// <summary>
/// Get all Files and Put them in a DataTable for the GridView
/// </summary>
/// <param name="currentFolderInfo">The current folder info.</param>
/// <returns>
/// The File Table
/// </returns>
public DataTable GetFiles(IFolderInfo currentFolderInfo)
{
var filesTable = new DataTable();
filesTable.Columns.Add(new DataColumn("FileName", typeof(string)));
filesTable.Columns.Add(new DataColumn("PictureURL", typeof(string)));
filesTable.Columns.Add(new DataColumn("Info", typeof(string)));
filesTable.Columns.Add(new DataColumn("FileId", typeof(int)));
HttpRequest httpRequest = HttpContext.Current.Request;
var type = "Link";
if (!string.IsNullOrEmpty(httpRequest.QueryString["Type"]))
{
type = httpRequest.QueryString["Type"];
}
// Get Folder Info Secure?
var isSecure =
this.GetStorageLocationType(currentFolderInfo.FolderID).Equals(
FolderController.StorageLocationTypes.SecureFileSystem);
var isDatabaseSecure =
this.GetStorageLocationType(currentFolderInfo.FolderID).Equals(
FolderController.StorageLocationTypes.DatabaseSecure);
var files = (List<IFileInfo>)FolderManager.Instance.GetFiles(currentFolderInfo);
if (this.SortFilesDescending)
{
Utility.SortDescending(files, item => item.FileName);
}
foreach (var fileItem in files)
{
// Check if File Exists
/*if (!File.Exists(string.Format("{0}{1}", fileItem.PhysicalPath, isSecure ? ".resources" : string.Empty)))
{
continue;
}*/
var item = fileItem;
var name = fileItem.FileName;
var extension = fileItem.Extension;
if (isSecure)
{
name = GetFileNameCleaned(name);
extension = Path.GetExtension(name);
}
switch (type)
{
case "Image":
{
foreach (DataRow dr in
from sAllowExt in this.allowedImageExt
where name.ToLower().EndsWith(sAllowExt)
select filesTable.NewRow())
{
if (isSecure || isDatabaseSecure)
{
var link = string.Format("fileID={0}", fileItem.FileId);
dr["PictureURL"] = Globals.LinkClick(link, int.Parse(this.request.QueryString["tabid"]), Null.NullInteger);
}
else
{
dr["PictureURL"] = MapUrl(fileItem.PhysicalPath);
}
dr["FileName"] = name;
dr["FileId"] = item.FileId;
dr["Info"] =
string.Format(
"<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>",
name,
fileItem.Size,
fileItem.LastModificationTime);
filesTable.Rows.Add(dr);
}
}
break;
case "Flash":
{
foreach (DataRow dr in
from sAllowExt in this.allowedFlashExt
where name.ToLower().EndsWith(sAllowExt)
select filesTable.NewRow())
{
dr["PictureURL"] = "images/types/swf.png";
dr["Info"] =
string.Format(
"<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>",
name,
fileItem.Size,
fileItem.LastModificationTime);
dr["FileName"] = name;
dr["FileId"] = item.FileId;
filesTable.Rows.Add(dr);
}
}
break;
default:
{
if (extension.StartsWith("."))
{
extension = extension.Replace(".", string.Empty);
}
if (extension.Count() <= 1 || !this.extensionWhiteList.Contains(extension.ToLower()))
{
continue;
}
DataRow dr = filesTable.NewRow();
var imageExtension = string.Format("images/types/{0}.png", extension);
if (File.Exists(this.MapPath(imageExtension)))
{
dr["PictureURL"] = imageExtension;
}
else
{
dr["PictureURL"] = "images/types/unknown.png";
}
if (this.allowedImageExt.Any(sAllowImgExt => name.ToLower().EndsWith(sAllowImgExt)))
{
if (isSecure || isDatabaseSecure)
{
var link = string.Format("fileID={0}", fileItem.FileId);
dr["PictureURL"] = Globals.LinkClick(link, int.Parse(this.request.QueryString["tabid"]), Null.NullInteger);
}
else
{
dr["PictureURL"] = MapUrl(fileItem.PhysicalPath);
}
}
dr["FileName"] = name;
dr["FileId"] = fileItem.FileId;
dr["Info"] =
string.Format(
"<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>",
name,
fileItem.Size,
fileItem.LastModificationTime);
filesTable.Rows.Add(dr);
}
break;
}
}
return filesTable;
}
/// <summary> /// Deletes the specified folder. /// </summary> public abstract void DeleteFolder(IFolderInfo folder);
/// <summary>
/// Set Folder Permission for the Current User
/// </summary>
/// <param name="folderInfo">The folder info.</param>
/// <param name="currentUserInfo">The current user info.</param>
private void SetUserFolderPermission(IFolderInfo folderInfo, UserInfo currentUserInfo)
{
if (FolderPermissionController.CanManageFolder((FolderInfo)folderInfo))
{
return;
}
foreach (
var folderPermission in from PermissionInfo permission in PermissionController.GetPermissionsByFolder()
where
permission.PermissionKey.ToUpper() == "READ"
|| permission.PermissionKey.ToUpper() == "WRITE"
|| permission.PermissionKey.ToUpper() == "BROWSE"
select
new FolderPermissionInfo(permission)
{
FolderID = folderInfo.FolderID,
UserID = currentUserInfo.UserID,
RoleID = Null.NullInteger,
AllowAccess = true
})
{
folderInfo.FolderPermissions.Add(folderPermission);
}
FolderPermissionController.SaveFolderPermissions((FolderInfo)folderInfo);
}
/// <summary> /// Checks the existence of the specified file in the underlying system. /// </summary> /// <returns></returns> public abstract bool FileExists(IFolderInfo folder, string fileName);
private void Create_Click(object sender, EventArgs e)
{
var ps = Security.PortalSecurity.Instance;
txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoScripting);
txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoMarkup);
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoScripting);
txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoMarkup);
if (RoleController.Instance.GetRoleByName(PortalId, txtGroupName.Text) != null)
{
lblInvalidGroupName.Visible = true;
return;
}
var modRoles = new List <RoleInfo>();
var modUsers = new List <UserInfo>();
foreach (ModulePermissionInfo modulePermissionInfo in ModulePermissionController.GetModulePermissions(ModuleId, TabId))
{
if (modulePermissionInfo.PermissionKey == "MODGROUP" && modulePermissionInfo.AllowAccess)
{
if (modulePermissionInfo.RoleID > int.Parse(Globals.glbRoleNothing))
{
modRoles.Add(RoleController.Instance.GetRoleById(PortalId, modulePermissionInfo.RoleID));
}
else if (modulePermissionInfo.UserID > Null.NullInteger)
{
modUsers.Add(UserController.GetUserById(PortalId, modulePermissionInfo.UserID));
}
}
}
var roleInfo = new RoleInfo()
{
PortalID = PortalId,
RoleName = txtGroupName.Text,
Description = txtDescription.Text,
SecurityMode = SecurityMode.SocialGroup,
Status = RoleStatus.Approved,
IsPublic = rdAccessTypePublic.Checked
};
var userRoleStatus = RoleStatus.Pending;
if (GroupModerationEnabled)
{
roleInfo.Status = RoleStatus.Pending;
userRoleStatus = RoleStatus.Pending;
}
else
{
userRoleStatus = RoleStatus.Approved;
}
var objModulePermissions = new ModulePermissionCollection(CBO.FillCollection(DataProvider.Instance().GetModulePermissionsByModuleID(ModuleId, -1), typeof(ModulePermissionInfo)));
if (ModulePermissionController.HasModulePermission(objModulePermissions, "MODGROUP"))
{
roleInfo.Status = RoleStatus.Approved;
userRoleStatus = RoleStatus.Approved;
}
var roleGroupId = DefaultRoleGroupId;
if (roleGroupId < Null.NullInteger)
{
roleGroupId = Null.NullInteger;
}
roleInfo.RoleGroupID = roleGroupId;
roleInfo.RoleID = RoleController.Instance.AddRole(roleInfo);
roleInfo = RoleController.Instance.GetRoleById(PortalId, roleInfo.RoleID);
var groupUrl = Globals.NavigateURL(GroupViewTabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() });
if (groupUrl.StartsWith("http://") || groupUrl.StartsWith("https://"))
{
const int startIndex = 8; // length of https://
groupUrl = groupUrl.Substring(groupUrl.IndexOf("/", startIndex, StringComparison.InvariantCultureIgnoreCase));
}
roleInfo.Settings.Add("URL", groupUrl);
roleInfo.Settings.Add("GroupCreatorName", UserInfo.DisplayName);
roleInfo.Settings.Add("ReviewMembers", chkMemberApproved.Checked.ToString());
RoleController.Instance.UpdateRoleSettings(roleInfo, true);
if (inpFile.PostedFile != null && 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.Instance.UpdateRole(roleInfo);
}
}
var notifications = new Notifications();
RoleController.Instance.AddUserRole(PortalId, UserId, roleInfo.RoleID, userRoleStatus, true, Null.NullDate, Null.NullDate);
if (roleInfo.Status == RoleStatus.Pending)
{
//Send notification to Group Moderators to approve/reject group.
notifications.AddGroupNotification(Constants.GroupPendingNotification, GroupViewTabId, ModuleId, roleInfo, UserInfo, modRoles, modUsers);
}
else
{
//Send notification to Group Moderators informing of new group.
notifications.AddGroupNotification(Constants.GroupCreatedNotification, GroupViewTabId, ModuleId, roleInfo, UserInfo, modRoles, modUsers);
//Add entry to journal.
GroupUtilities.CreateJournalEntry(roleInfo, UserInfo);
}
Response.Redirect(Globals.NavigateURL(GroupViewTabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() }));
}
/// <summary> /// Gets the list of file names contained in the specified folder. /// </summary> /// <returns></returns> public abstract string[] GetFiles(IFolderInfo folder);
/// <summary>
/// Gets a file Stream of the specified file.
/// </summary>
/// <returns></returns>
public virtual Stream GetFileStream(IFolderInfo folder, IFileInfo file, int version)
{
return(this.GetFileStream(folder, FileVersionController.GetVersionedFilename(file, version)));
}
internal static bool CanEdit(IFolderInfo folder) => folder != null && FolderPermissionController.CanAddFolder(folder as FolderInfo);
