public int AddFolder(FolderInfo folder)
{
var tmpFolder = FolderManager.Instance.GetFolder(folder.PortalID, folder.FolderPath);
if (tmpFolder != null && folder.FolderID == Null.NullInteger)
{
folder.FolderID = tmpFolder.FolderID;
}
if (folder.FolderID == Null.NullInteger)
{
folder = (FolderInfo)FolderManager.Instance.AddFolder(FolderMappingController.Instance.GetFolderMapping(folder.PortalID, folder.FolderMappingID), folder.FolderPath);
}
else
{
FolderManager.Instance.UpdateFolder(folder);
}
return folder.FolderID;
}
public void CollectData(FolderInfo folderInfo, int startIndex, int portalId)
{
ArrayList filesWorking = FileSystemUtils.GetFilesByFolder(portalId, folderInfo.FolderID);
if (filesWorking != null)
{
foreach (DotNetNuke.Services.FileSystem.FileInfo fileInfo in filesWorking)
{
ParseCSV(fileInfo, startIndex);
}
}
ImportData(this.portalId);
}
public int AddFolder(int PortalID, string FolderPath, int StorageLocation, bool IsProtected, bool IsCached)
{
var objFolder = new FolderInfo();
objFolder.UniqueId = Guid.NewGuid();
objFolder.VersionGuid = Guid.NewGuid();
objFolder.PortalID = PortalID;
objFolder.FolderPath = FolderPath;
objFolder.StorageLocation = StorageLocation;
objFolder.IsProtected = IsProtected;
objFolder.IsCached = IsCached;
return AddFolder(objFolder);
}
public void UpdateFolder(FolderInfo objFolderInfo)
{
FolderManager.Instance.UpdateFolder(objFolderInfo);
}
public static void AddAllUserReadPermission(FolderInfo folder, PermissionInfo permission)
{
FolderManager.Instance.AddAllUserReadPermission(folder, permission);
}
/// <summary>
/// Render all Directories and sub directories recursive
/// </summary>
/// <param name="folderInfo">The folder Info.</param>
/// <returns>
/// TreeNode List
/// </returns>
private RadTreeNode RenderFolder(FolderInfo folderInfo)
{
if (!FolderPermissionController.CanViewFolder(folderInfo))
{
return null;
}
RadTreeNode tnFolder = new RadTreeNode
{
Text = folderInfo.FolderName,
Value = folderInfo.PhysicalPath,
ImageUrl = "Images/folder.gif",
ExpandedImageUrl = "Images/folderOpen.gif",
ToolTip = folderInfo.FolderID.ToString()
};
if (folderInfo.StorageLocation.Equals((int)FolderController.StorageLocationTypes.SecureFileSystem))
{
tnFolder.ImageUrl = "Images/folderLocked.gif";
tnFolder.ExpandedImageUrl = "Images/folderOpenLocked.gif";
}
else if (folderInfo.StorageLocation.Equals((int)FolderController.StorageLocationTypes.DatabaseSecure))
{
tnFolder.ImageUrl = "Images/folderdb.gif";
tnFolder.ExpandedImageUrl = "Images/folderdb.gif";
}
/*ArrayList folders = FileSystemUtils.GetFoldersByParentFolder(
this._portalSettings.PortalId, folderInfo.FolderPath);*/
var folders = FolderManager.Instance.GetFolders(folderInfo).ToList();
if (folders.Any())
{
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;
}
tnFolder.Nodes.Add(node);
}
}
return tnFolder;
}
/// <summary>
/// SaveFolderPermissions updates a Folder's permissions
/// </summary>
/// <param name="folder">The Folder to update</param>
public virtual void SaveFolderPermissions(FolderInfo folder)
{
SaveFolderPermissions((IFolderInfo)folder);
}
/// <summary>
/// Returns a flag indicating whether the current user can manage a folder's settings
/// </summary>
/// <param name="folder">The page</param>
/// <returns>A flag indicating whether the user has permission</returns>
public virtual bool CanManageFolder(FolderInfo folder)
{
return HasFolderPermission(folder, ManageFolderPermissionKey);
}
public void OverwriteFolder_Deletes_Source_Folder_In_Database()
{
var fileManager = new Mock<IFileManager>();
FileManager.RegisterInstance(fileManager.Object);
_folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId);
_folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_ValidFolderRelativePath);
_folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID);
var files = new List<IFileInfo>();
_mockFolderManager.Setup(mfm => mfm.GetFiles(_folderInfo.Object, It.IsAny<bool>(), It.IsAny<bool>())).Returns(files);
var destinationFolder = new FolderInfo();
_mockFolderManager.Setup(mfm => mfm.DeleteFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Verifiable();
var folderMapping = new FolderMappingInfo();
_mockFolderManager.Setup(mfm => mfm.GetFolderMapping(It.IsAny<Dictionary<int, FolderMappingInfo>>(), Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping);
_mockFolderManager.Setup(mfm => mfm.IsFolderMappingEditable(folderMapping)).Returns(false);
_mockFolderManager.Object.OverwriteFolder(_folderInfo.Object, destinationFolder, new Dictionary<int, FolderMappingInfo>(), new SortedList<string, IFolderInfo>());
_mockFolderManager.Verify();
}
public void OverwriteFolder_Calls_MoveFile_For_Each_File_In_Source_Folder()
{
_folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId);
_folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_ValidFolderRelativePath);
_folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID);
var destinationFolder = new FolderInfo();
var file1 = new FileInfo();
var file2 = new FileInfo();
var file3 = new FileInfo();
var files = new List<IFileInfo> { file1, file2, file3 };
_mockFolderManager.Setup(mfm => mfm.GetFiles(_folderInfo.Object, It.IsAny<bool>(), It.IsAny<bool>())).Returns(files);
var fileManager = new Mock<IFileManager>();
FileManager.RegisterInstance(fileManager.Object);
fileManager.Setup(fm => fm.MoveFile(It.IsAny<IFileInfo>(), destinationFolder));
_mockFolderManager.Setup(mfm => mfm.DeleteFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath));
var folderMapping = new FolderMappingInfo();
_mockFolderManager.Setup(mfm => mfm.GetFolderMapping(It.IsAny<Dictionary<int, FolderMappingInfo>>(), Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping);
_mockFolderManager.Setup(mfm => mfm.IsFolderMappingEditable(folderMapping)).Returns(false);
_mockFolderManager.Object.OverwriteFolder(_folderInfo.Object, destinationFolder, new Dictionary<int, FolderMappingInfo>(), new SortedList<string, IFolderInfo>());
fileManager.Verify(fm => fm.MoveFile(It.IsAny<IFileInfo>(), destinationFolder), Times.Exactly(3));
}
public void MoveFolder_Throws_When_Move_Operation_Is_Not_Valid()
{
_folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_ValidFolderRelativePath);
_folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID);
IFolderInfo destinationFolder = new FolderInfo();
destinationFolder.FolderPath = Constants.FOLDER_OtherValidFolderRelativePath;
destinationFolder.FolderMappingID = Constants.FOLDER_ValidFolderMappingID;
_pathUtils.Setup(pu => pu.FormatFolderPath(Constants.FOLDER_OtherValidFolderRelativePath)).Returns(Constants.FOLDER_OtherValidFolderRelativePath);
_mockFolderManager.Setup(mfm => mfm.FolderExists(It.IsAny<int>(), It.IsAny<string>())).Returns(false);
_mockFolderManager.Setup(mfm => mfm.CanMoveBetweenFolderMappings(It.IsAny<FolderMappingInfo>(), It.IsAny<FolderMappingInfo>())).Returns(true);
_mockFolderManager.Setup(mfm => mfm.IsMoveOperationValid(_folderInfo.Object, destinationFolder, It.IsAny<string>())).Returns(false);
_mockFolderManager.Object.MoveFolder(_folderInfo.Object, destinationFolder);
}
public void MoveFolder_Returns_The_Same_Folder_If_The_Paths_Are_The_Same()
{
_folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_ValidFolderRelativePath);
IFolderInfo destinationFolder = new FolderInfo();
destinationFolder.FolderPath = Constants.FOLDER_ValidFolderRelativePath;
_pathUtils.Setup(pu => pu.FormatFolderPath(Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderRelativePath);
var movedFolder = _folderManager.MoveFolder(_folderInfo.Object, destinationFolder);
Assert.AreEqual(_folderInfo.Object, movedFolder);
}
/// <summary>
/// Processes all Files from the template
/// </summary>
/// <param name="nodeFiles">Template file node for the Files</param>
/// <param name="PortalId">PortalId of the new portal</param>
/// <history>
/// [cnurse] 11/09/2004 Created
/// </history>
private void ParseFiles( XmlNodeList nodeFiles, int PortalId, FolderInfo objFolder )
{
int FileId = 0;
FileController objController = new FileController();
FileInfo objInfo = null;
string fileName = null;
foreach( XmlNode node in nodeFiles )
{
fileName = XmlUtils.GetNodeValue( node, "filename", "" );
//First check if the file exists
objInfo = objController.GetFile( fileName, PortalId, objFolder.FolderID );
if( objInfo == null )
{
objInfo = new FileInfo();
objInfo.PortalId = PortalId;
objInfo.FileName = fileName;
objInfo.Extension = XmlUtils.GetNodeValue( node, "extension", "" );
objInfo.Size = XmlUtils.GetNodeValueInt( node, "size", 0 );
objInfo.Width = XmlUtils.GetNodeValueInt( node, "width", 0 );
objInfo.Height = XmlUtils.GetNodeValueInt( node, "height", 0 );
objInfo.ContentType = XmlUtils.GetNodeValue( node, "contenttype", "" );
objInfo.FolderId = objFolder.FolderID;
objInfo.Folder = objFolder.FolderPath;
//Save new File
FileId = objController.AddFile( objInfo );
}
else
{
//Get Id from File
FileId = objInfo.FileId;
}
}
}
/// <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(FolderInfo currentFolderInfo)
{
DataTable 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 filesArrayList = FileSystemUtils.GetFilesByFolder(
this._portalSettings.PortalId, currentFolderInfo.FolderID);
var files = filesArrayList.OfType<DotNetNuke.Services.FileSystem.FileInfo>().ToList();
if (this.SortFilesDescending)
{
Utility.SortDescending(files, item => item.FileName);
}
foreach (DotNetNuke.Services.FileSystem.FileInfo 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":
{
// Show Images only
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>",
name,
fileItem.Size);
filesTable.Rows.Add(dr);
}
}
break;
case "Flash":
{
// Show Flash Files only
foreach (DataRow dr in
from sAllowExt in this.allowedFlashExt
where name.ToLower().EndsWith(sAllowExt)
select filesTable.NewRow())
{
dr["PictureURL"] = "images/types/swf.png";
dr["FileName"] = name;
dr["FileId"] = item.FileId;
dr["Info"] =
string.Format(
"<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span>",
name,
fileItem.Size);
filesTable.Rows.Add(dr);
}
}
break;
default:
{
// Show all allowed File types
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>",
name,
fileItem.Size);
filesTable.Rows.Add(dr);
}
break;
}
}
return filesTable;
}
private static void RemoveOrphanedFiles( FolderInfo folder, int PortalId )
{
FileController objFileController = new FileController();
if( folder.StorageLocation != (int)FolderController.StorageLocationTypes.DatabaseSecure )
{
foreach( Services.FileSystem.FileInfo objFile in GetFilesByFolder( PortalId, folder.FolderID ) )
{
RemoveOrphanedFile( objFile, PortalId );
}
}
}
private bool CheckAllChildrenVisible(ref FolderInfo folder)
{
string virtualPath = FileSystemValidation.ToVirtualPath(folder.FolderPath);
//check files are visible
var files = GetDNNFiles(folder.FolderID);
var visibleFileCount = 0;
foreach (Services.FileSystem.FileInfo fileItem in files.Values)
{
if (CheckSearchPatterns(fileItem.FileName, SearchPatterns))
{
visibleFileCount = visibleFileCount + 1;
}
}
if (visibleFileCount != Directory.GetFiles(HttpContext.Current.Request.MapPath(virtualPath)).Length)
{
return false;
}
//check folders
if (folder != null)
{
IDictionary<string, FolderInfo> childUserFolders = DNNValidator.GetChildUserFolders(virtualPath);
if (childUserFolders.Count != Directory.GetDirectories(HttpContext.Current.Request.MapPath(virtualPath)).Length)
{
return false;
}
//check children
foreach (FolderInfo childFolder in childUserFolders.Values)
{
//do recursive check
FolderInfo tempVar2 = childFolder;
if (! (CheckAllChildrenVisible(ref tempVar2)))
{
return false;
}
}
}
return true;
}
/// <summary>
/// Returns a flag indicating whether the current user can delete a folder or file
/// </summary>
/// <param name="folder">The page</param>
/// <returns>A flag indicating whether the user has permission</returns>
public virtual bool CanDeleteFolder(FolderInfo folder)
{
return HasFolderPermission(folder, DeleteFolderPermissionKey);
}
public void OverwriteFolder_Adds_Folder_To_FoldersToDelete_If_FolderMapping_Is_Editable()
{
var fileManager = new Mock<IFileManager>();
FileManager.RegisterInstance(fileManager.Object);
_folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId);
_folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_ValidFolderRelativePath);
_folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID);
var files = new List<IFileInfo>();
_mockFolderManager.Setup(mfm => mfm.GetFiles(_folderInfo.Object, It.IsAny<bool>(), It.IsAny<bool>())).Returns(files);
var destinationFolder = new FolderInfo();
_mockFolderManager.Setup(mfm => mfm.DeleteFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath));
var folderMapping = new FolderMappingInfo();
_mockFolderManager.Setup(mfm => mfm.GetFolderMapping(It.IsAny<Dictionary<int, FolderMappingInfo>>(), Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping);
_mockFolderManager.Setup(mfm => mfm.IsFolderMappingEditable(folderMapping)).Returns(true);
var foldersToDelete = new SortedList<string, IFolderInfo>();
_mockFolderManager.Object.OverwriteFolder(_folderInfo.Object, destinationFolder, new Dictionary<int, FolderMappingInfo>(), foldersToDelete);
Assert.AreEqual(1, foldersToDelete.Count);
}
/// <summary>
/// Returns a flag indicating whether the current user can view a folder or file
/// </summary>
/// <param name="folder">The page</param>
/// <returns>A flag indicating whether the user has permission</returns>
public virtual bool CanViewFolder(FolderInfo folder)
{
return HasFolderPermission(folder, ViewFolderPermissionKey);
}
public void GetFolder_Returns_Valid_Folder_When_Folder_Exists_Overload()
{
_pathUtils.Setup(pu => pu.FormatFolderPath(Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderRelativePath);
_pathUtils.Setup(pu => pu.RemoveTrailingSlash(Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderName);
var folderDataTable = new DataTable();
folderDataTable.Columns.Add("FolderName");
folderDataTable.Rows.Add(Constants.FOLDER_ValidFolderName);
var dr = folderDataTable.CreateDataReader();
_mockData.Setup(md => md.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(dr);
var folderInfo = new FolderInfo { FolderPath = Constants.FOLDER_ValidFolderRelativePath };
_cbo.Setup(cbo => cbo.FillObject<FolderInfo>(dr)).Returns(folderInfo);
_mockFolderManager.Setup(mfm => mfm.GetFolders(Constants.CONTENT_ValidPortalId)).Returns(new List<IFolderInfo>());
var result = _mockFolderManager.Object.GetFolder(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath);
Assert.AreEqual(Constants.FOLDER_ValidFolderName, result.FolderName);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (Request.QueryString["Folder"] != null)
{
//DNN upload when provided with a GUID of the folder ID being used
DotNetNuke.Services.FileSystem.FolderInfo FI = new DotNetNuke.Services.FileSystem.FolderInfo();
string folder = Request.QueryString["Folder"].ToString();
if (!String.IsNullOrEmpty(folder))
{
FI = (DotNetNuke.Services.FileSystem.FolderInfo)FolderManager.Instance.GetFolder(Guid.Parse(folder));
FileManager.Instance.AddFile(FI, Request.Files[0].FileName, Request.Files[0].InputStream);
Response.Write("{\"success\":true}");
}
else
{
Response.Write("{\"error\":\"" + "string fileName: cannot be empty or null" + "\"}");
}
}
else if (Request.QueryString["FilePath"] != null)
{
//Uses standard asp file upload
string filePath = null;
byte[] rawFile = null;
using (BinaryReader binaryReader = new BinaryReader(Request.Files[0].InputStream))
{
rawFile = binaryReader.ReadBytes(Request.Files[0].ContentLength);
filePath = Request.Files[0].FileName.ToLower();
}
//Check if the folder exists, and if it doesn't create it
string folder = Request.QueryString["FilePath"].ToString();
if (Directory.Exists(Server.MapPath(folder)) == false)
{
Directory.CreateDirectory(Server.MapPath(folder));
}
string msAddOn = DateTime.Now.Millisecond.ToString();
string fileName = Path.GetFileNameWithoutExtension(filePath) + "_" + msAddOn + Path.GetExtension(filePath);
if (!String.IsNullOrEmpty(fileName))
{
//Checks if it is an image or not
if (folder.ToLower().Contains("/photos/"))
{
//Get Format
ImageFormat MyFormat = ImageFormat.Jpeg;
if (fileName.EndsWith(".png"))
{
MyFormat = ImageFormat.Png;
}
else if (fileName.EndsWith(".bmp"))
{
MyFormat = ImageFormat.Bmp;
}
//Resize image and create a thumbnail for it
System.Drawing.Image rawFileImage = ByteArrayToImage(rawFile); //Convert rawFile Byte array to Image to process Image Resize
System.Drawing.Image rawThumbFileImage = ByteArrayToImage(rawFile);
ResizeImage((Bitmap)rawFileImage, 900, 900, fileName).Save(Server.MapPath(folder + fileName), MyFormat); //regular
ResizeImage((Bitmap)rawThumbFileImage, 200, 200, fileName).Save(Server.MapPath(folder + "thumb_" + fileName), MyFormat); //thumbnail
}
else if (folder.ToLower().Contains("/videos/"))
{
//if it's the poster
if (fileName.EndsWith(".png") || fileName.EndsWith(".jpg"))
{
System.Drawing.Image rawFileImage = ByteArrayToImage(rawFile);
ResizeImage((Bitmap)rawFileImage, 900, 900, fileName).Save(Server.MapPath(folder + fileName), ImageFormat.Jpeg);
}
else
{
//if it's the video
File.WriteAllBytes(Server.MapPath(folder + fileName), rawFile);
}
}
else if (folder.ToLower().Contains("/slides/"))
{
System.Drawing.Image rawFileImage = ByteArrayToImage(rawFile);
ResizeImage((Bitmap)rawFileImage, 900, 900, fileName).Save(Server.MapPath(folder + fileName), ImageFormat.Jpeg);
}
else
{
File.WriteAllBytes(Server.MapPath(folder + fileName), rawFile);
}
Response.Write("{\"success\":true, \"msAddOn\":" + msAddOn + "}");
//syncs files right away so they can be viewed in the html editor.
int PID = DotNetNuke.Entities.Portals.PortalController.Instance.GetCurrentPortalSettings().PortalId;
string syncpath = Server.MapPath(folder);
//syncs the folder the file was added to.
DotNetNuke.Services.FileSystem.FolderManager.Instance.Synchronize(PID, syncpath, true, true);
//syncs the whole portal.
DotNetNuke.Services.FileSystem.FolderManager.Instance.Synchronize(PID);
}
else
{
Response.Write("{\"errors\":\"" + "string fileName: cannot be empty or null" + "\"}");
}
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
Response.Write("{\"error\":\"" + ex.Message + "\"}");
}
}
private static void AddFolderAndMoveFiles(string folderPath, string newFolderPath, FolderMappingInfo folderMapping)
{
var folderProvider = Instance(folderMapping.FolderProviderType);
if (!folderProvider.FolderExists(newFolderPath, folderMapping))
{
folderProvider.AddFolder(newFolderPath, folderMapping);
}
var folder = new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID };
var newFolder = new FolderInfo { FolderPath = newFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID };
MoveFiles(folder, newFolder, folderMapping);
}
private static void RemoveOrphanedFiles(FolderInfo folder, int PortalId)
{
if (folder.FolderMappingID != FolderMappingController.Instance.GetFolderMapping(PortalId, "Database").FolderMappingID)
{
foreach (FileInfo objFile in FolderManager.Instance.GetFiles(folder))
{
RemoveOrphanedFile(objFile, PortalId);
}
}
}
/// <summary>
/// Copies the specified file to the destination folder.
/// </summary>
public virtual void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping)
{
Requires.NotNull("folderPath", folderPath);
Requires.NotNullOrEmpty("fileName", fileName);
Requires.NotNull("newFolderPath", newFolderPath);
Requires.NotNull("folderMapping", folderMapping);
if (folderPath == newFolderPath) return;
var sourceFolder = new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID };
var destinationFolder = new FolderInfo { FolderPath = newFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID };
using (var fileContent = GetFileStream(sourceFolder, fileName))
{
if (!fileContent.CanSeek)
{
using (var seekableStream = FileManager.Instance.GetSeekableStream(fileContent))
{
AddFile(destinationFolder, fileName, seekableStream);
}
}
else
{
AddFile(destinationFolder, fileName, fileContent);
}
}
}
public static string AddFile(string strFile, int PortalId, bool ClearCache, FolderInfo folder)
{
var fileManager = FileManager.Instance;
var fileName = GetFileName(strFile);
var file = (FileInfo)fileManager.GetFile(folder, fileName);
if (file == null)
{
file = new FileInfo { PortalId = PortalId, FolderId = folder.FolderID, FileName = fileName };
using (var fileContent = fileManager.GetFileContent(file))
{
fileManager.AddFile(folder, GetFileName(strFile), fileContent, false);
}
}
else
{
using (var fileContent = fileManager.GetFileContent(file))
{
fileManager.UpdateFile(file, fileContent);
}
}
return "";
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Adds node to tree
/// </summary>
/// <param name="folder">The FolderInfo object to add</param>
/// <param name="objNodes">Node collection to add to</param>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 04/24/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private DNNTreeNode AddNode(FolderInfo folder, DNNTreeNodeCollection objNodes)
{
DNNTreeNode objNode;
string strName = folder.FolderName;
string strKey = MaskPath(RootFolderPath + folder.FolderPath);
var subFolders = FolderManager.Instance.GetFolders(folder).ToList();
var imageIndex = FolderMappings.IndexOfKey(folder.FolderMappingID);
objNode = AddNode(strName, strKey, imageIndex, objNodes);
objNode.HasNodes = subFolders.Count > 0;
return objNode;
}
public int AddFolder(int PortalID, string FolderPath)
{
var objFolder = new FolderInfo();
objFolder.UniqueId = Guid.NewGuid();
objFolder.VersionGuid = Guid.NewGuid();
objFolder.PortalID = PortalID;
objFolder.FolderPath = FolderPath;
objFolder.StorageLocation = (int) StorageLocationTypes.InsecureFileSystem;
objFolder.IsProtected = false;
objFolder.IsCached = false;
return AddFolder(objFolder);
}
private bool HasFolderPermission(FolderInfo folder, string permissionKey)
{
if (folder == null) return false;
return (PortalSecurity.IsInRoles(folder.FolderPermissions.ToString(permissionKey))
|| PortalSecurity.IsInRoles(folder.FolderPermissions.ToString(AdminFolderPermissionKey)))
&& !PortalSecurity.IsDenied(folder.FolderPermissions.ToString(permissionKey));
//Deny on Edit permission on folder shouldn't take away any other explicitly Allowed
//&& !PortalSecurity.IsDenied(folder.FolderPermissions.ToString(AdminFolderPermissionKey));
}
/// <summary>
/// Returns a flag indicating whether the current user can browse the folder
/// </summary>
/// <param name="folder">The page</param>
/// <returns>A flag indicating whether the user has permission</returns>
public virtual bool CanBrowseFolder(FolderInfo folder)
{
if (folder == null) return false;
return (PortalSecurity.IsInRoles(folder.FolderPermissions.ToString(BrowseFolderPermissionKey))
|| PortalSecurity.IsInRoles(folder.FolderPermissions.ToString(ViewFolderPermissionKey)))
&& !PortalSecurity.IsDenied(folder.FolderPermissions.ToString(BrowseFolderPermissionKey));
}
/// <summary>
/// Returns a flag indicating whether the current user can addmister a folder
/// </summary>
/// <param name="folder">The page</param>
/// <returns>A flag indicating whether the user has permission</returns>
public virtual bool CanAdminFolder(FolderInfo folder)
{
if (folder == null) return false;
return PortalSecurity.IsInRoles(folder.FolderPermissions.ToString(AdminFolderPermissionKey));
}
public void StageData(ArrayList files, FolderInfo folderInfo)
{
FileController fc = new FileController();
if (folderInfo != null && files != null)
{
foreach (DotNetNuke.Services.FileSystem.FileInfo fileInfo in files)
{
if (File.Exists(fileInfo.PhysicalPath))
{
File.Move(fileInfo.PhysicalPath, folderInfo.PhysicalPath + fileInfo.FileName);
fc.UpdateFile(fileInfo.FileId, fileInfo.FileName, fileInfo.Extension.Substring(1), fileInfo.Size, Null.NullInteger, Null.NullInteger, fileInfo.ContentType, folderInfo.PhysicalPath, folderInfo.FolderID);
}
}
}
}
public void UpdateFolder(FolderInfo objFolderInfo)
{
FolderManager.Instance.UpdateFolder(objFolderInfo);
}