public int ConvertFilePathToFileId(string FilePath, int PortalID)
{
string FileName = "";
string FolderName = "";
int FileId = -1;
if (!String.IsNullOrEmpty(FilePath))
{
FileName = FilePath.Substring(FilePath.LastIndexOf("/") + 1);
FolderName = FilePath.Replace(FileName, "");
}
FileController objFiles = new FileController();
FolderController objFolders = new FolderController();
FolderInfo objFolder = objFolders.GetFolder(PortalID, FolderName, false);
if (objFolder != null)
{
FileInfo objFile = objFiles.GetFile(FileName, PortalID, objFolder.FolderID);
if (objFile != null)
{
FileId = objFile.FileId;
}
}
return(FileId);
}
private static int AddFolder(int PortalId, string relativePath, int StorageLocation)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
bool isProtected = FileSystemUtils.DefaultProtectedFolders(relativePath);
int FolderID = objFolderController.AddFolder(PortalId, relativePath, StorageLocation, isProtected, false);
if (PortalId != Null.NullInteger)
{
SetFolderPermissions(PortalId, FolderID, relativePath);
}
return FolderID;
}
private static string AddFile(int PortalId, Stream inStream, string fileName, string contentType, long length, string folderName, bool closeInputStream, bool clearCache, bool synchronize)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FileController objFileController = new CommonLibrary.Services.FileSystem.FileController();
string sourceFolderName = Globals.GetSubFolderPath(fileName, PortalId);
CommonLibrary.Services.FileSystem.FolderInfo folder = objFolderController.GetFolder(PortalId, sourceFolderName, false);
string sourceFileName = GetFileName(fileName);
int intFileID;
string retValue = "";
retValue += CheckValidFileName(fileName);
if (!String.IsNullOrEmpty(retValue))
{
return retValue;
}
string extension = Path.GetExtension(fileName).Replace(".", "");
if (String.IsNullOrEmpty(contentType))
{
contentType = GetContentType(extension);
}
intFileID = objFileController.AddFile(PortalId, sourceFileName, extension, length, Null.NullInteger, Null.NullInteger, contentType, folderName, folder.FolderID, clearCache);
if (folder.StorageLocation != (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem || synchronize == false)
{
WriteStream(intFileID, inStream, fileName, folder.StorageLocation, closeInputStream);
}
retValue += UpdateFileData(intFileID, folder.FolderID, PortalId, sourceFileName, extension, contentType, length, folderName);
if (folder.StorageLocation != (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem)
{
DeleteFile(fileName);
}
if (folder.StorageLocation != (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.SecureFileSystem)
{
if (!fileName.EndsWith(".template"))
{
DeleteFile(fileName + Globals.glbProtectedExtension);
}
}
return retValue;
}
public int ConvertFilePathToFileId(string FilePath, int PortalID)
{
string FileName = "";
string FolderName = "";
int FileId = -1;
if (!String.IsNullOrEmpty(FilePath))
{
FileName = FilePath.Substring(FilePath.LastIndexOf("/") + 1);
FolderName = FilePath.Replace(FileName, "");
}
FileController objFiles = new FileController();
FolderController objFolders = new FolderController();
FolderInfo objFolder = objFolders.GetFolder(PortalID, FolderName, false);
if (objFolder != null)
{
FileInfo objFile = objFiles.GetFile(FileName, PortalID, objFolder.FolderID);
if (objFile != null)
{
FileId = objFile.FileId;
}
}
return FileId;
}
public static string UnzipFile(string fileName, string DestFolder, PortalSettings settings)
{
ZipInputStream objZipInputStream = null;
string strMessage = "";
try
{
int FolderPortalId = GetFolderPortalId(settings);
bool isHost = settings.ActiveTab.ParentId == settings.SuperTabId;
PortalController objPortalController = new PortalController();
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FileController objFileController = new CommonLibrary.Services.FileSystem.FileController();
string sourceFolderName = Globals.GetSubFolderPath(fileName, FolderPortalId);
string sourceFileName = GetFileName(fileName);
CommonLibrary.Services.FileSystem.FolderInfo folder = objFolderController.GetFolder(FolderPortalId, sourceFolderName, false);
CommonLibrary.Services.FileSystem.FileInfo file = objFileController.GetFile(sourceFileName, FolderPortalId, folder.FolderID);
int storageLocation = folder.StorageLocation;
ZipEntry objZipEntry;
string strFileName = "";
string strExtension;
try
{
objZipInputStream = new ZipInputStream(GetFileStream(file));
}
catch (Exception ex)
{
return ex.Message;
}
ArrayList sortedFolders = new ArrayList();
objZipEntry = objZipInputStream.GetNextEntry();
while (objZipEntry != null)
{
if (objZipEntry.IsDirectory)
{
try
{
sortedFolders.Add(objZipEntry.Name.ToString());
}
catch (Exception ex)
{
objZipInputStream.Close();
return ex.Message;
}
}
objZipEntry = objZipInputStream.GetNextEntry();
}
sortedFolders.Sort();
foreach (string s in sortedFolders)
{
try
{
AddFolder(settings, DestFolder, s.ToString(), storageLocation);
}
catch (Exception ex)
{
return ex.Message;
}
}
objZipInputStream = new ZipInputStream(GetFileStream(file));
objZipEntry = objZipInputStream.GetNextEntry();
while (objZipEntry != null)
{
if (!objZipEntry.IsDirectory)
{
if (objPortalController.HasSpaceAvailable(FolderPortalId, objZipEntry.Size))
{
strFileName = Path.GetFileName(objZipEntry.Name);
if (!String.IsNullOrEmpty(strFileName))
{
strExtension = Path.GetExtension(strFileName).Replace(".", "");
if (("," + Host.FileExtensions.ToLower()).IndexOf("," + strExtension.ToLower()) != 0 || isHost)
{
try
{
string folderPath = System.IO.Path.GetDirectoryName(DestFolder + objZipEntry.Name.Replace("/", "\\"));
DirectoryInfo Dinfo = new DirectoryInfo(folderPath);
if (!Dinfo.Exists)
{
AddFolder(settings, DestFolder, objZipEntry.Name.Substring(0, objZipEntry.Name.Replace("/", "\\").LastIndexOf("\\")));
}
string zipEntryFileName = DestFolder + objZipEntry.Name.Replace("/", "\\");
strMessage += AddFile(FolderPortalId, objZipInputStream, zipEntryFileName, "", objZipEntry.Size, Globals.GetSubFolderPath(zipEntryFileName, settings.PortalId), false, false);
}
catch (Exception ex)
{
if (objZipInputStream != null)
{
objZipInputStream.Close();
}
return ex.Message;
}
}
else
{
strMessage += "<br>" + string.Format(Localization.GetString("RestrictedFileType"), strFileName, Host.FileExtensions.Replace(",", ", *."));
}
}
}
else
{
strMessage += "<br>" + string.Format(Localization.GetString("DiskSpaceExceeded"), strFileName);
}
}
objZipEntry = objZipInputStream.GetNextEntry();
}
}
finally
{
if (objZipInputStream != null)
{
objZipInputStream.Close();
objZipInputStream.Dispose();
}
}
return strMessage;
}
public static void SynchronizeFolder(int PortalId, string physicalPath, string relativePath, bool isRecursive, bool syncFiles, bool forceFolderSync, bool hideSystemFolders)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
int FolderId;
bool isInSync = true;
if (forceFolderSync == true && String.IsNullOrEmpty(relativePath))
{
RemoveOrphanedFolders(PortalId);
}
CommonLibrary.Services.FileSystem.FolderInfo folder = objFolderController.GetFolder(PortalId, relativePath, false);
DirectoryInfo dirInfo = new DirectoryInfo(physicalPath);
if (dirInfo.Exists)
{
if (folder == null)
{
if (ShouldSyncFolder(hideSystemFolders, dirInfo))
{
FolderId = AddFolder(PortalId, relativePath, (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem);
folder = objFolderController.GetFolder(PortalId, relativePath, true);
isInSync = false;
}
else
{
//Prevent further processing of this folder
return;
}
}
else
{
isInSync = (dirInfo.LastWriteTime.ToString("yyyyMMddhhmmss") == folder.LastUpdated.ToString("yyyyMMddhhmmss"));
}
if (folder != null)
{
if (syncFiles == true && (isInSync == false || forceFolderSync == true))
{
string[] strFiles = Directory.GetFiles(physicalPath);
foreach (string strFileName in strFiles)
{
AddFile(strFileName, PortalId, false, folder);
}
RemoveOrphanedFiles(folder, PortalId);
folder.LastUpdated = dirInfo.LastWriteTime;
objFolderController.UpdateFolder(folder);
}
if (isRecursive)
{
string[] strFolders = Directory.GetDirectories(physicalPath);
foreach (string strFolder in strFolders)
{
DirectoryInfo dir = new DirectoryInfo(strFolder);
string relPath = Null.NullString;
if (String.IsNullOrEmpty(relativePath))
{
relPath = dir.Name + "/";
}
else
{
relPath = relativePath;
if (!relativePath.EndsWith("/"))
{
relPath = relPath + "/";
}
relPath = relPath + dir.Name + "/";
}
SynchronizeFolder(PortalId, strFolder, relPath, true, syncFiles, forceFolderSync, hideSystemFolders);
}
}
}
}
else
{
if (folder != null)
{
if (folder.StorageLocation != (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.DatabaseSecure)
{
RemoveOrphanedFiles(folder, PortalId);
objFolderController.DeleteFolder(PortalId, relativePath.Replace("\\", "/"));
}
}
}
}
public static void SetFolderPermission(int PortalId, int FolderId, int PermissionId, int RoleId, int UserId, string relativePath)
{
FolderPermissionInfo objFolderPermissionInfo;
CommonLibrary.Services.FileSystem.FolderController objController = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo folder = objController.GetFolderInfo(PortalId, FolderId);
foreach (FolderPermissionInfo fpi in folder.FolderPermissions)
{
if (fpi.FolderID == FolderId
&& fpi.PermissionID == PermissionId
&& fpi.RoleID == RoleId
&& fpi.UserID == UserId
&& fpi.AllowAccess == true)
{
return;
}
}
objFolderPermissionInfo = new FolderPermissionInfo();
objFolderPermissionInfo.FolderID = FolderId;
objFolderPermissionInfo.PermissionID = PermissionId;
objFolderPermissionInfo.RoleID = RoleId;
objFolderPermissionInfo.UserID = UserId;
objFolderPermissionInfo.AllowAccess = true;
folder.FolderPermissions.Add(objFolderPermissionInfo, true);
FolderPermissionController.SaveFolderPermissions(folder);
}
private void AddFolderPermissions(int PortalId, int folderId)
{
PortalInfo objPortal = GetPortal(PortalId);
FolderController objController = new FolderController();
FolderPermissionInfo objFolderPermission;
FolderInfo folder = objController.GetFolderInfo(PortalId, folderId);
PermissionController objPermissionController = new PermissionController();
foreach (PermissionInfo objpermission in objPermissionController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", ""))
{
objFolderPermission = new FolderPermissionInfo(objpermission);
objFolderPermission.FolderID = folder.FolderID;
objFolderPermission.RoleID = objPortal.AdministratorRoleId;
folder.FolderPermissions.Add(objFolderPermission);
if (objpermission.PermissionKey == "READ")
{
objFolderPermission = new FolderPermissionInfo(objpermission);
objFolderPermission.FolderID = folder.FolderID;
objFolderPermission.RoleID = int.Parse(Globals.glbRoleAllUsers);
folder.FolderPermissions.Add(objFolderPermission);
}
}
FolderPermissionController.SaveFolderPermissions(folder);
}
public static void DeleteFolder(int PortalId, System.IO.DirectoryInfo folder, string folderName)
{
folder.Delete(false);
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
objFolderController.DeleteFolder(PortalId, folderName.Replace("\\", "/"));
}
public static void AddFile(string FileName, int PortalId, string Folder, string HomeDirectoryMapPath, string contentType)
{
string strFile = HomeDirectoryMapPath + Folder + FileName;
CommonLibrary.Services.FileSystem.FileController objFiles = new CommonLibrary.Services.FileSystem.FileController();
System.IO.FileInfo finfo = new System.IO.FileInfo(strFile);
CommonLibrary.Services.FileSystem.FolderController objFolders = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo objFolder = objFolders.GetFolder(PortalId, Folder, false);
CommonLibrary.Services.FileSystem.FileInfo objFile;
objFile = objFiles.GetFile(FileName, PortalId, objFolder.FolderID);
if (objFile == null)
{
objFiles.AddFile(PortalId, FileName, finfo.Extension, finfo.Length, 0, 0, contentType, "", objFolder.FolderID, true);
}
else
{
objFiles.UpdateFile(objFile.FileId, objFile.FileName, finfo.Extension, finfo.Length, 0, 0, contentType, "", objFolder.FolderID);
}
}
public static CommonLibrary.Services.FileSystem.FolderInfo GetFolder(int PortalID, string FolderPath)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo objFolder = objFolderController.GetFolder(PortalID, FolderPath, false);
if (Host.EnableFileAutoSync)
{
if (objFolder != null)
{
SynchronizeFolder(objFolder.PortalID, objFolder.PhysicalPath, objFolder.FolderPath, false, true, false, false);
}
}
return objFolder;
}
public static ArrayList GetFolders(int PortalID)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
ArrayList arrFolders = new ArrayList();
foreach (KeyValuePair<string, CommonLibrary.Services.FileSystem.FolderInfo> folderPair in objFolderController.GetFoldersSorted(PortalID))
{
arrFolders.Add(folderPair.Value);
}
return arrFolders;
}
private static string CreateFile(string RootPath, string FileName, long ContentLength, string ContentType, Stream InputStream, string NewFileName, bool Unzip)
{
// Obtain PortalSettings from Current Context
PortalSettings settings = PortalController.GetCurrentPortalSettings();
int PortalId = GetFolderPortalId(settings);
bool isHost = (bool)(settings.ActiveTab.ParentId == settings.SuperTabId ? true : false);
PortalController objPortalController = new PortalController();
string strMessage = "";
string strFileName = FileName;
if (NewFileName != Null.NullString) strFileName = NewFileName;
strFileName = RootPath + Path.GetFileName(strFileName);
string strExtension = Path.GetExtension(strFileName).Replace(".", "");
string strFolderpath = Globals.GetSubFolderPath(strFileName, PortalId);
CommonLibrary.Services.FileSystem.FolderController objFolders = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo objFolder = objFolders.GetFolder(PortalId, strFolderpath, false);
if (FolderPermissionController.CanAdminFolder(objFolder))
{
if (objPortalController.HasSpaceAvailable(PortalId, ContentLength))
{
if (("," + Host.FileExtensions.ToUpper()).IndexOf("," + strExtension.ToUpper()) != -1 || isHost)
{
//Save Uploaded file to server
try
{
strMessage += AddFile(PortalId, InputStream, strFileName, ContentType, ContentLength, strFolderpath, true, true);
//Optionally Unzip File?
if (Path.GetExtension(strFileName).ToLower() == ".zip" & Unzip == true)
{
strMessage += UnzipFile(strFileName, RootPath, settings);
}
}
catch (Exception exc)
{
// save error - can happen if the security settings are incorrect on the disk
strMessage += "<br>" + string.Format(Localization.GetString("SaveFileError"), strFileName);
exc.ToString();
}
}
else
{
// restricted file type
strMessage += "<br>" + string.Format(Localization.GetString("RestrictedFileType"), strFileName, Host.FileExtensions.Replace(",", ", *."));
}
}
else
{
// file too large
strMessage += "<br>" + string.Format(Localization.GetString("DiskSpaceExceeded"), strFileName);
}
}
else
{
// insufficient folder permission in the application
strMessage += "<br>" + string.Format(Localization.GetString("InsufficientFolderPermission"), strFolderpath);
}
return strMessage;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// ParseFiles parses the Host Template's Files node
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="node">The Files node</param>
/// <param name="portalId">The PortalId (-1 for Host Files)</param>
/// <history>
/// [cnurse] 11/08/2004 created
/// </history>
/// -----------------------------------------------------------------------------
private static void ParseFiles(XmlNode node, int portalId)
{
FileSystem.FileController objController = new FileSystem.FileController();
//Parse the File nodes
foreach (XmlNode fileNode in node.SelectNodes("file"))
{
string strFileName = XmlUtils.GetNodeValue(fileNode.CreateNavigator(), "filename");
string strExtenstion = XmlUtils.GetNodeValue(fileNode.CreateNavigator(), "extension");
long fileSize = long.Parse(XmlUtils.GetNodeValue(fileNode.CreateNavigator(), "size"));
int iWidth = XmlUtils.GetNodeValueInt(fileNode, "width");
int iHeight = XmlUtils.GetNodeValueInt(fileNode, "height");
string strType = XmlUtils.GetNodeValue(fileNode.CreateNavigator(), "contentType");
string strFolder = XmlUtils.GetNodeValue(fileNode.CreateNavigator(), "folder");
FolderController objFolders = new FolderController();
FolderInfo objFolder = objFolders.GetFolder(portalId, strFolder, false);
objController.AddFile(portalId, strFileName, strExtenstion, fileSize, iWidth, iHeight, strType, strFolder, objFolder.FolderID, true
);
}
}
private void ParseFolders(XmlNode nodeFolders, int PortalId)
{
int FolderId;
FolderController objController = new FolderController();
FolderInfo objInfo;
string folderPath;
int storageLocation;
bool isProtected = false;
foreach (XmlNode node in nodeFolders.SelectNodes("//folder"))
{
folderPath = XmlUtils.GetNodeValue(node.CreateNavigator(), "folderpath");
objInfo = objController.GetFolder(PortalId, folderPath, false);
if (objInfo == null)
{
isProtected = FileSystemUtils.DefaultProtectedFolders(folderPath);
if (isProtected == true)
{
storageLocation = (int)FolderController.StorageLocationTypes.InsecureFileSystem;
}
else
{
storageLocation = Convert.ToInt32(XmlUtils.GetNodeValue(node, "storagelocation", "0"));
isProtected = XmlUtils.GetNodeValueBoolean(node, "isprotected");
}
FolderId = objController.AddFolder(PortalId, folderPath, storageLocation, isProtected, false);
objInfo = objController.GetFolder(PortalId, folderPath, false);
}
else
{
FolderId = objInfo.FolderID;
}
XmlNodeList nodeFolderPermissions = node.SelectNodes("folderpermissions/permission");
ParseFolderPermissions(nodeFolderPermissions, PortalId, objInfo);
XmlNodeList nodeFiles = node.SelectNodes("files/file");
if (!String.IsNullOrEmpty(folderPath))
{
folderPath += "/";
}
ParseFiles(nodeFiles, PortalId, objInfo);
}
}
private static string UpdateFile(string strSourceFile, string strDestFile, int PortalId, bool isCopy, bool isNew, bool ClearCache)
{
string retValue = "";
retValue += CheckValidFileName(strSourceFile) + " ";
retValue += CheckValidFileName(strDestFile);
if (retValue.Length > 1)
{
return retValue;
}
retValue = "";
Stream sourceStream = null;
try
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FileController objFileController = new CommonLibrary.Services.FileSystem.FileController();
string sourceFolderName = Globals.GetSubFolderPath(strSourceFile, PortalId);
string sourceFileName = GetFileName(strSourceFile);
CommonLibrary.Services.FileSystem.FolderInfo sourceFolder = objFolderController.GetFolder(PortalId, sourceFolderName, false);
string destFileName = GetFileName(strDestFile);
string destFolderName = Globals.GetSubFolderPath(strDestFile, PortalId);
CommonLibrary.Services.FileSystem.FileInfo file;
if (sourceFolder != null)
{
file = objFileController.GetFile(sourceFileName, PortalId, sourceFolder.FolderID);
if (file != null)
{
sourceStream = (Stream)GetFileStream(file);
if (isCopy)
{
AddFile(PortalId, sourceStream, strDestFile, "", file.Size, destFolderName, true, ClearCache);
}
else
{
CommonLibrary.Services.FileSystem.FolderInfo destinationFolder = objFolderController.GetFolder(PortalId, destFolderName, false);
if (destinationFolder != null)
{
objFileController.UpdateFile(file.FileId, destFileName, file.Extension, file.Size, file.Width, file.Height, file.ContentType, destFolderName, destinationFolder.FolderID);
WriteStream(file.FileId, sourceStream, strDestFile, destinationFolder.StorageLocation, true);
if (sourceFolder.StorageLocation == (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem)
{
DeleteFile(strSourceFile);
}
if (sourceFolder.StorageLocation == (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.SecureFileSystem)
{
DeleteFile(strSourceFile + Globals.glbProtectedExtension);
}
}
}
}
}
}
catch (Exception ex)
{
retValue = ex.Message;
}
finally
{
if (sourceStream != null)
{
sourceStream.Close();
sourceStream.Dispose();
}
}
return retValue;
}
public static ArrayList GetFoldersByUser(int PortalID, bool IncludeSecure, bool IncludeDatabase, string Permissions)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
ArrayList arrFolders = new ArrayList();
foreach (CommonLibrary.Services.FileSystem.FolderInfo folder in objFolderController.GetFoldersSorted(PortalID).Values)
{
bool canAdd = true;
switch (folder.StorageLocation)
{
case (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.DatabaseSecure:
canAdd = IncludeDatabase;
break;
case (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.SecureFileSystem:
canAdd = IncludeSecure;
break;
}
if (canAdd && PortalID > Null.NullInteger)
{
canAdd = FolderPermissionController.HasFolderPermission(folder.FolderPermissions, Permissions);
}
if (canAdd)
{
arrFolders.Add(folder);
}
}
return arrFolders;
}
public static void RemoveOrphanedFolders(int PortalId)
{
CommonLibrary.Services.FileSystem.FolderController objFolderController = new CommonLibrary.Services.FileSystem.FolderController();
ArrayList arrFolders = GetFolders(PortalId);
foreach (CommonLibrary.Services.FileSystem.FolderInfo objFolder in arrFolders)
{
if (objFolder.StorageLocation != (int)CommonLibrary.Services.FileSystem.FolderController.StorageLocationTypes.DatabaseSecure)
{
if (Directory.Exists(objFolder.PhysicalPath) == false)
{
RemoveOrphanedFiles(objFolder, PortalId);
objFolderController.DeleteFolder(PortalId, objFolder.FolderPath);
}
}
}
}
//-----------------------------------------------------------------------------
//<summary>
//Creates a User Folder
//</summary>
//<param name="_PortalSettings">Portal Settings for the Portal</param>
//<param name="parentFolder">The Parent Folder Name</param>
//<param name="UserID">The UserID, in order to generate the path/foldername</param>
//<param name="StorageLocation">The Storage Location</param>
//<remarks>
//</remarks>
//<history>
// [jlucarino] 02/26/2010 Created
//</history>
//-----------------------------------------------------------------------------
public static void AddUserFolder(PortalSettings _PortalSettings, string parentFolder, int StorageLocation, int UserID)
{
int PortalId = 0;
string ParentFolderName = null;
System.IO.DirectoryInfo dinfoNew = default(System.IO.DirectoryInfo);
string RootFolder = "";
string SubFolder = "";
PortalId = _PortalSettings.PortalId;
ParentFolderName = _PortalSettings.HomeDirectoryMapPath;
RootFolder = GetUserFolderPathElement(UserID, EnumUserFolderElement.Root);
SubFolder = GetUserFolderPathElement(UserID, EnumUserFolderElement.SubFolder);
//create root folder
string folderPath = "";
folderPath = System.IO.Path.Combine(Path.Combine(ParentFolderName, "Users"), RootFolder);
dinfoNew = new System.IO.DirectoryInfo(folderPath);
if (!dinfoNew.Exists)
{
dinfoNew.Create();
AddFolder(PortalId, folderPath.Substring(ParentFolderName.Length).Replace("\\", "/"), StorageLocation);
}
//create two-digit subfolder
folderPath = System.IO.Path.Combine(folderPath, SubFolder);
dinfoNew = new System.IO.DirectoryInfo(folderPath);
if (!dinfoNew.Exists)
{
dinfoNew.Create();
AddFolder(PortalId, folderPath.Substring(ParentFolderName.Length).Replace("\\", "/"), StorageLocation);
}
//create folder from UserID
folderPath = System.IO.Path.Combine(folderPath, UserID.ToString());
dinfoNew = new System.IO.DirectoryInfo(folderPath);
if (!dinfoNew.Exists)
{
dinfoNew.Create();
int folderID = AddFolder(PortalId, folderPath.Substring(ParentFolderName.Length).Replace("\\", "/"), StorageLocation);
//Give user Read Access to this folder
CommonLibrary.Services.FileSystem.FolderInfo folder = new CommonLibrary.Services.FileSystem.FolderController().GetFolderInfo(PortalId, folderID);
foreach (PermissionInfo permission in PermissionController.GetPermissionsByFolder())
{
if (permission.PermissionKey.ToUpper() == "READ" || permission.PermissionKey.ToUpper() == "WRITE")
{
FolderPermissionInfo folderPermission = new FolderPermissionInfo(permission);
folderPermission.FolderID = folder.FolderID;
folderPermission.UserID = UserID;
folderPermission.RoleID = Null.NullInteger;
folderPermission.AllowAccess = true;
folder.FolderPermissions.Add(folderPermission);
}
}
FolderPermissionController.SaveFolderPermissions(folder);
}
}
public static void SetFolderPermissions(int PortalId, int FolderId, int AdministratorRoleId, string relativePath)
{
CommonLibrary.Services.FileSystem.FolderInfo folder = new CommonLibrary.Services.FileSystem.FolderController().GetFolderInfo(PortalId, FolderId);
foreach (PermissionInfo objPermission in PermissionController.GetPermissionsByFolder())
{
FolderPermissionInfo folderPermission = new FolderPermissionInfo(objPermission);
folderPermission.FolderID = FolderId;
folderPermission.RoleID = AdministratorRoleId;
folder.FolderPermissions.Add(folderPermission, true);
}
FolderPermissionController.SaveFolderPermissions(folder);
}
public static string DeleteFile(string strSourceFile, PortalSettings settings, bool ClearCache)
{
string retValue = "";
int PortalId = GetFolderPortalId(settings);
string folderName = Globals.GetSubFolderPath(strSourceFile, PortalId);
string fileName = GetFileName(strSourceFile);
CommonLibrary.Services.FileSystem.FolderController objFolders = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo objFolder = objFolders.GetFolder(PortalId, folderName, false);
if (FolderPermissionController.CanAdminFolder(objFolder))
{
try
{
DeleteFile(strSourceFile);
DeleteFile(strSourceFile + Globals.glbProtectedExtension);
CommonLibrary.Services.FileSystem.FileController objFileController = new CommonLibrary.Services.FileSystem.FileController();
objFileController.DeleteFile(PortalId, fileName, objFolder.FolderID, ClearCache);
}
catch (IOException ioEx)
{
retValue += "<br>" + string.Format(Localization.GetString("FileInUse"), strSourceFile);
ioEx.ToString();
}
catch (Exception ex)
{
retValue = ex.Message;
}
}
else
{
retValue += "<br>" + string.Format(Localization.GetString("InsufficientFolderPermission"), folderName);
}
return retValue;
}
public static void SetFolderPermissions(int PortalId, int FolderId, string relativePath)
{
if (!String.IsNullOrEmpty(relativePath))
{
CommonLibrary.Services.FileSystem.FolderInfo folder = new CommonLibrary.Services.FileSystem.FolderController().GetFolderInfo(PortalId, FolderId);
string parentFolderPath = relativePath.Substring(0, relativePath.Substring(0, relativePath.Length - 1).LastIndexOf("/") + 1);
foreach (FolderPermissionInfo objPermission in FolderPermissionController.GetFolderPermissionsCollectionByFolder(PortalId, parentFolderPath))
{
FolderPermissionInfo folderPermission = new FolderPermissionInfo(objPermission);
folderPermission.FolderID = FolderId;
folderPermission.RoleID = objPermission.RoleID;
folderPermission.UserID = objPermission.UserID;
folderPermission.AllowAccess = objPermission.AllowAccess;
folder.FolderPermissions.Add(folderPermission, true);
}
FolderPermissionController.SaveFolderPermissions(folder);
}
}
public static bool DownloadFile(int PortalId, int FileId, bool ClientCache, bool ForceDownload)
{
bool blnDownload = false;
CommonLibrary.Services.FileSystem.FileController objFiles = new CommonLibrary.Services.FileSystem.FileController();
CommonLibrary.Services.FileSystem.FileInfo objFile = objFiles.GetFileById(FileId, PortalId);
if (objFile != null)
{
string filename = objFile.FileName;
if (HttpContext.Current.Request.UserAgent.IndexOf("; MSIE ") > 0)
{
filename = HttpUtility.UrlEncode(filename);
}
CommonLibrary.Services.FileSystem.FolderController objFolders = new CommonLibrary.Services.FileSystem.FolderController();
CommonLibrary.Services.FileSystem.FolderInfo objFolder = objFolders.GetFolder(PortalId, objFile.Folder, false);
if (FolderPermissionController.CanViewFolder(objFolder))
{
bool blnFileExists = true;
if (Host.EnableFileAutoSync)
{
string strFile = "";
switch (objFile.StorageLocation)
{
case (int)FolderController.StorageLocationTypes.InsecureFileSystem:
strFile = objFile.PhysicalPath;
break;
case (int)FolderController.StorageLocationTypes.SecureFileSystem:
strFile = objFile.PhysicalPath + Globals.glbProtectedExtension;
break;
}
if (!String.IsNullOrEmpty(strFile))
{
System.IO.FileInfo objFileInfo = new System.IO.FileInfo(strFile);
if (objFileInfo.Exists)
{
if (objFile.Size != objFileInfo.Length)
{
objFile.Size = Convert.ToInt32(objFileInfo.Length);
UpdateFileData(FileId, objFile.FolderId, PortalId, objFile.FileName, objFile.Extension, GetContentType(objFile.Extension), objFileInfo.Length, objFile.Folder);
}
}
else
{
RemoveOrphanedFile(objFile, PortalId);
blnFileExists = false;
}
}
}
if (blnFileExists)
{
int scriptTimeOut = HttpContext.Current.Server.ScriptTimeout;
HttpContext.Current.Server.ScriptTimeout = int.MaxValue;
HttpResponse objResponse = HttpContext.Current.Response;
objResponse.ClearContent();
objResponse.ClearHeaders();
if (ForceDownload)
{
objResponse.AppendHeader("content-disposition", "attachment; filename=\"" + filename + "\"");
}
else
{
objResponse.AppendHeader("content-disposition", "inline; filename=\"" + filename + "\"");
}
objResponse.AppendHeader("Content-Length", objFile.Size.ToString());
objResponse.ContentType = GetContentType(objFile.Extension.Replace(".", ""));
System.IO.Stream objStream = null;
try
{
objStream = FileSystemUtils.GetFileStream(objFile);
WriteStream(objResponse, objStream);
}
catch (Exception ex)
{
objResponse.Write("Error : " + ex.Message);
}
finally
{
if (objStream != null)
{
objStream.Close();
objStream.Dispose();
}
}
objResponse.Flush();
objResponse.End();
HttpContext.Current.Server.ScriptTimeout = scriptTimeOut;
blnDownload = true;
}
}
}
return blnDownload;
}
public void ParseTemplate(int PortalId, string TemplatePath, string TemplateFile, int AdministratorId, PortalTemplateModuleAction mergeTabs, bool IsNewPortal)
{
XmlDocument xmlPortal = new XmlDocument();
XmlNode node;
try
{
xmlPortal.Load(TemplatePath + TemplateFile);
}
catch
{
}
node = xmlPortal.SelectSingleNode("//portal/settings");
if (node != null && IsNewPortal)
{
ParsePortalSettings(node, PortalId);
}
node = xmlPortal.SelectSingleNode("//portal/rolegroups");
if (node != null)
{
ParseRoleGroups(node.CreateNavigator(), PortalId, AdministratorId);
}
node = xmlPortal.SelectSingleNode("//portal/roles");
if (node != null)
{
ParseRoles(node.CreateNavigator(), PortalId, AdministratorId);
}
node = xmlPortal.SelectSingleNode("//portal/portalDesktopModules");
if (node != null)
{
ParsePortalDesktopModules(node.CreateNavigator(), PortalId);
}
node = xmlPortal.SelectSingleNode("//portal/folders");
if (node != null)
{
ParseFolders(node, PortalId);
}
var objController = new FolderController();
if (objController.GetFolder(PortalId, "", false) == null)
{
int folderid = objController.AddFolder(PortalId, "", (int)Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem, true, false);
AddFolderPermissions(PortalId, folderid);
}
if (objController.GetFolder(PortalId, "Templates/", false) == null)
{
int folderid = objController.AddFolder(PortalId, "Templates/", (int)Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem, true, false);
AddFolderPermissions(PortalId, folderid);
}
// force creation of templates folder if not present on template
if (objController.GetFolder(PortalId, "Users/", false) == null)
{
int folderid = objController.AddFolder(PortalId, "Users/", (int)Services.FileSystem.FolderController.StorageLocationTypes.InsecureFileSystem, true, false);
AddFolderPermissions(PortalId, folderid);
}
if (mergeTabs == PortalTemplateModuleAction.Replace)
{
var objTabs = new TabController();
TabInfo objTab;
foreach (KeyValuePair<int, TabInfo> tabPair in objTabs.GetTabsByPortal(PortalId))
{
objTab = tabPair.Value;
objTab.TabName = objTab.TabName + "_old";
objTab.TabPath = Common.Globals.GenerateTabPath(objTab.ParentId, objTab.TabName);
objTab.IsDeleted = true;
objTabs.UpdateTab(objTab);
var objModules = new ModuleController();
ModuleInfo objModule;
foreach (KeyValuePair<int, ModuleInfo> modulePair in objModules.GetTabModules(objTab.TabID))
{
objModule = modulePair.Value;
objModules.DeleteTabModule(objModule.TabID, objModule.ModuleID, false);
}
}
}
node = xmlPortal.SelectSingleNode("//portal/tabs");
if (node != null)
{
string version = xmlPortal.DocumentElement.GetAttribute("version");
if (version != "5.0")
{
var xmlAdmin = new XmlDocument();
try
{
xmlAdmin.Load(TemplatePath + "admin.template");
}
catch
{
}
XmlNode adminNode = xmlAdmin.SelectSingleNode("//portal/tabs");
foreach (XmlNode adminTabNode in adminNode.ChildNodes)
{
node.AppendChild(xmlPortal.ImportNode(adminTabNode, true));
}
}
ParseTabs(node, PortalId, false, mergeTabs, IsNewPortal);
}
}
