public void GivenThereIsAPageCalled(string pageName, Table permissions)
{
var reset = false;
var tabController = new TabController();
var tab = tabController.GetTabByName(pageName, PortalId);
if (tab == null)
{
tab = new TabInfo
{
TabName = pageName,
PortalID = 0
};
tab.TabID = tabController.AddTab(tab);
foreach (var row in permissions.Rows)
{
var roleId = -1;
var roleController = new RoleController();
if (row[0] == "All Users")
{
roleId = -1;
}
else
{
var role = roleController.GetRoleByName(PortalId, row[0]);
if (role == null)
{
if (roleController.GetRoleByName(Null.NullInteger, row[0]) == null)
{
role = new RoleInfo { RoleName = row[0], RoleGroupID = Null.NullInteger };
roleId = roleController.AddRole(role);
}
}
}
var permissionController = new PermissionController();
var permission = permissionController.GetPermissionByCodeAndKey("SYSTEM_TAB", row[1]);
var tabPermission = new TabPermissionInfo
{
PermissionID = 3,
TabID = tab.TabID,
AllowAccess = true,
RoleID = roleId
};
tab.TabPermissions.Add(tabPermission);
}
tabController.UpdateTab(tab);
reset = true;
}
Page = tab;
if (reset)
{
Config.Touch();
}
}
public static void ensureFolderExists(int portalId)
{
FolderMappingInfo fm = FolderMappingController.Instance.GetFolderMapping(portalId, "Secure");
if (!FolderManager.Instance.FolderExists(portalId, IMAGE_FOLDER + "/"))
{
IFolderInfo f1 = FolderManager.Instance.AddFolder(fm, IMAGE_FOLDER);
DotNetNuke.Security.Roles.RoleController rc = new DotNetNuke.Security.Roles.RoleController();
DotNetNuke.Security.Permissions.PermissionController pc = new DotNetNuke.Security.Permissions.PermissionController();
DotNetNuke.Security.Permissions.PermissionInfo w = (DotNetNuke.Security.Permissions.PermissionInfo)pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "WRITE")[0];
FolderManager.Instance.SetFolderPermission(f1, w.PermissionID, rc.GetRoleByName(portalId, "Accounts Team").RoleID);
}
}
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);
}
/// <summary>
/// Adds the module to page.
/// </summary>
/// <param name="portalId">The portal id.</param>
/// <param name="tabId">The tab id.</param>
/// <exception cref="System.ArgumentException">desktopModuleId</exception>
private void AddModuleToPage(int portalId, int tabId)
{
TabPermissionCollection objTabPermissions = new TabController().GetTab(tabId, portalId, false).TabPermissions;
var objPermissionController = new PermissionController();
var objModules = new ModuleController();
new EventLogController();
int desktopModuleId =
DesktopModuleController.GetDesktopModuleByFriendlyName("VanityURLs").DesktopModuleID;
try
{
DesktopModuleInfo desktopModule;
if (!DesktopModuleController.GetDesktopModules(portalId).TryGetValue(desktopModuleId, out desktopModule))
{
throw new ArgumentException("desktopModuleId");
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
}
foreach (ModuleDefinitionInfo objModuleDefinition in
ModuleDefinitionController.GetModuleDefinitionsByDesktopModuleID(desktopModuleId).Values)
{
var objModule = new ModuleInfo();
objModule.PortalID = portalId;
objModule.TabID = tabId;
objModule.ModuleOrder = 0;
objModule.ModuleTitle = objModuleDefinition.FriendlyName;
objModule.PaneName = "ContentPane";
objModule.ModuleDefID = objModuleDefinition.ModuleDefID;
objModule.InheritViewPermissions = true;
objModule.CultureCode = Null.NullString;
objModule.AllTabs = false;
objModules.AddModule(objModule);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PermissionController"/> class.
/// </summary>
public PermissionController()
{
this.permissionController = new DotNetNuke.Security.Permissions.PermissionController();
}
/// -----------------------------------------------------------------------------
/// <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")
{
//Try to add Read permission
var newFolderPerm = new FolderPermissionInfo(readPerm)
{
FolderID = folderPermission.FolderID,
RoleID = folderPermission.RoleID,
UserID = folderPermission.UserID,
AllowAccess = folderPermission.AllowAccess
};
additionalPermissions.Add(newFolderPerm);
//Try to add Browse permission
newFolderPerm = new FolderPermissionInfo(browsePerm)
{
FolderID = folderPermission.FolderID,
RoleID = folderPermission.RoleID,
UserID = folderPermission.UserID,
AllowAccess = folderPermission.AllowAccess
};
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 string ToString(string key)
{
return(PermissionController.BuildPermissions(List, key));
}
private IFolderInfo EnsureGroupFolder(int groupId, PortalSettings portalSettings)
{
const int AllUsersRoleId = -1;
var groupFolderPath = "Groups/" + groupId;
if (!FolderManager.Instance.FolderExists(portalSettings.PortalId, groupFolderPath))
{
var pc = new PermissionController();
var browsePermission = pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "BROWSE").Cast<PermissionInfo>().FirstOrDefault();
var readPermission = pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "READ").Cast<PermissionInfo>().FirstOrDefault();
var writePermission = pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "WRITE").Cast<PermissionInfo>().FirstOrDefault();
if (!FolderManager.Instance.FolderExists(portalSettings.PortalId, "Groups"))
{
var folder = FolderManager.Instance.AddFolder(portalSettings.PortalId, "Groups");
folder.FolderPermissions.Remove(browsePermission.PermissionID, AllUsersRoleId, Null.NullInteger);
folder.FolderPermissions.Remove(readPermission.PermissionID, AllUsersRoleId, Null.NullInteger);
folder.IsProtected = true;
FolderManager.Instance.UpdateFolder(folder);
}
var groupFolder = FolderManager.Instance.AddFolder(portalSettings.PortalId, groupFolderPath);
groupFolder.FolderPermissions.Add(new FolderPermissionInfo(browsePermission) { FolderPath = groupFolder.FolderPath, RoleID = groupId, AllowAccess = true });
groupFolder.FolderPermissions.Add(new FolderPermissionInfo(readPermission) { FolderPath = groupFolder.FolderPath, RoleID = groupId, AllowAccess = true });
groupFolder.FolderPermissions.Add(new FolderPermissionInfo(writePermission) { FolderPath = groupFolder.FolderPath, RoleID = groupId, AllowAccess = true });
groupFolder.IsProtected = true;
FolderManager.Instance.UpdateFolder(groupFolder);
return groupFolder;
}
return FolderManager.Instance.GetFolder(portalSettings.PortalId, groupFolderPath);
}
/// -----------------------------------------------------------------------------
/// <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))
{
//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);
}
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.Instance.GetCurrentUserInfo().UserID);
}
}
}
private int LocalizeModuleInternal(ModuleInfo sourceModule)
{
int moduleId = Null.NullInteger;
if (sourceModule != null)
{
// clone the module object ( to avoid creating an object reference to the data cache )
var newModule = sourceModule.Clone();
newModule.ModuleID = Null.NullInteger;
string translatorRoles = PortalController.GetPortalSetting(string.Format("DefaultTranslatorRoles-{0}", sourceModule.CultureCode), sourceModule.PortalID, "").TrimEnd(';');
//Add the default translators for this language, view and edit permissions
var permissionController = new PermissionController();
var viewPermissionsList = permissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "VIEW");
var editPermissionsList = permissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "EDIT");
PermissionInfo viewPermisison = null;
PermissionInfo editPermisison = null;
//View
if (viewPermissionsList != null && viewPermissionsList.Count > 0)
{
viewPermisison = (PermissionInfo)viewPermissionsList[0];
}
//Edit
if (editPermissionsList != null && editPermissionsList.Count > 0)
{
editPermisison = (PermissionInfo)editPermissionsList[0];
}
if (viewPermisison != null || editPermisison != null)
{
foreach (string translatorRole in translatorRoles.Split(';'))
{
AddModulePermission(ref newModule, sourceModule.PortalID, translatorRole, viewPermisison, "VIEW");
AddModulePermission(ref newModule, sourceModule.PortalID, translatorRole, editPermisison, "EDIT");
}
}
//Add Module
AddModuleInternal(newModule);
//copy module settings
Hashtable settings = GetModuleSettings(sourceModule.ModuleID);
//Copy each setting to the new TabModule instance
foreach (DictionaryEntry setting in settings)
{
UpdateModuleSetting(newModule.ModuleID, Convert.ToString(setting.Key), Convert.ToString(setting.Value));
}
// update tabmodule
dataProvider.UpdateTabModule(newModule.TabModuleID,
newModule.TabID,
newModule.ModuleID,
newModule.ModuleTitle,
newModule.Header,
newModule.Footer,
newModule.ModuleOrder,
newModule.PaneName,
newModule.CacheTime,
newModule.CacheMethod,
newModule.Alignment,
newModule.Color,
newModule.Border,
newModule.IconFile,
(int)newModule.Visibility,
newModule.ContainerSrc,
newModule.DisplayTitle,
newModule.DisplayPrint,
newModule.DisplaySyndicate,
newModule.IsWebSlice,
newModule.WebSliceTitle,
newModule.WebSliceExpiryDate,
newModule.WebSliceTTL,
newModule.VersionGuid,
newModule.DefaultLanguageGuid,
newModule.LocalizedVersionGuid,
newModule.CultureCode,
UserController.GetCurrentUserInfo().UserID);
if (!string.IsNullOrEmpty(newModule.DesktopModule.BusinessControllerClass))
{
try
{
object businessController = Reflection.CreateObject(newModule.DesktopModule.BusinessControllerClass, newModule.DesktopModule.BusinessControllerClass);
var portableModule = businessController as IPortable;
if (portableModule != null)
{
string Content = portableModule.ExportModule(sourceModule.ModuleID);
if (!string.IsNullOrEmpty(Content))
{
portableModule.ImportModule(newModule.ModuleID, Content, newModule.DesktopModule.Version, UserController.GetCurrentUserInfo().UserID);
}
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
}
}
moduleId = newModule.ModuleID;
//Clear Caches
ClearCache(newModule.TabID);
ClearCache(sourceModule.TabID);
}
return moduleId;
}
public void InitialModulePermission(ModuleInfo module, int tabId, int permissionType)
{
var tabPermissions = TabPermissionController.GetTabPermissions(tabId, module.PortalID);
var permissionController = new PermissionController();
module.InheritViewPermissions = permissionType == 0;
// get the default module view permissions
ArrayList systemModuleViewPermissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "VIEW");
// get the permissions from the page
foreach (TabPermissionInfo tabPermission in tabPermissions)
{
if (tabPermission.PermissionKey == "VIEW" && permissionType == 0)
{
//Don't need to explicitly add View permisisons if "Same As Page"
continue;
}
// get the system module permissions for the permissionkey
ArrayList systemModulePermissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", tabPermission.PermissionKey);
// loop through the system module permissions
int j;
for (j = 0; j <= systemModulePermissions.Count - 1; j++)
{
// create the module permission
var systemModulePermission = (PermissionInfo) systemModulePermissions[j];
if (systemModulePermission.PermissionKey == "VIEW" && permissionType == 1 && tabPermission.PermissionKey != "EDIT")
{
//Only Page Editors get View permissions if "Page Editors Only"
continue;
}
ModulePermissionInfo modulePermission = AddModulePermission(module, systemModulePermission, tabPermission.RoleID, tabPermission.UserID, tabPermission.AllowAccess);
// ensure that every EDIT permission which allows access also provides VIEW permission
if (modulePermission.PermissionKey == "EDIT" && modulePermission.AllowAccess)
{
AddModulePermission(module, (PermissionInfo) systemModuleViewPermissions[0], modulePermission.RoleID, modulePermission.UserID, true);
}
}
//Get the custom Module Permissions, Assume that roles with Edit Tab Permissions
//are automatically assigned to the Custom Module Permissions
if (tabPermission.PermissionKey == "EDIT")
{
ArrayList customModulePermissions = permissionController.GetPermissionsByModuleDefID(module.ModuleDefID);
// loop through the custom module permissions
for (j = 0; j <= customModulePermissions.Count - 1; j++)
{
// create the module permission
var customModulePermission = (PermissionInfo)customModulePermissions[j];
AddModulePermission(module, customModulePermission, tabPermission.RoleID, tabPermission.UserID, tabPermission.AllowAccess);
}
}
}
}
private int AddNewModule(TabInfo tab, string title, int desktopModuleId, string paneName, int permissionType, string align)
{
TabPermissionCollection objTabPermissions = tab.TabPermissions;
var objPermissionController = new PermissionController();
var objModules = new ModuleController();
int j;
var mdc = new ModuleDefinitionController();
foreach (ModuleDefinitionInfo objModuleDefinition in ModuleDefinitionController.GetModuleDefinitionsByDesktopModuleID(desktopModuleId).Values)
{
var objModule = new ModuleInfo();
objModule.Initialize(tab.PortalID);
objModule.PortalID = tab.PortalID;
objModule.TabID = tab.TabID;
if (string.IsNullOrEmpty(title))
{
objModule.ModuleTitle = objModuleDefinition.FriendlyName;
}
else
{
objModule.ModuleTitle = title;
}
objModule.PaneName = paneName;
objModule.ModuleDefID = objModuleDefinition.ModuleDefID;
objModule.CacheTime = 0;
objModule.InheritViewPermissions = true;
objModule.DisplayTitle = false;
// get the default module view permissions
ArrayList arrSystemModuleViewPermissions = objPermissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "VIEW");
// get the permissions from the page
foreach (TabPermissionInfo objTabPermission in objTabPermissions)
{
if (objTabPermission.PermissionKey == "VIEW" && permissionType == 0)
{
//Don't need to explicitly add View permisisons if "Same As Page"
continue;
}
// get the system module permissions for the permissionkey
ArrayList arrSystemModulePermissions = objPermissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", objTabPermission.PermissionKey);
// loop through the system module permissions
for (j = 0; j <= arrSystemModulePermissions.Count - 1; j++)
{
// create the module permission
PermissionInfo objSystemModulePermission = default(PermissionInfo);
objSystemModulePermission = (PermissionInfo) arrSystemModulePermissions[j];
if (objSystemModulePermission.PermissionKey == "VIEW" && permissionType == 1 && objTabPermission.PermissionKey != "EDIT")
{
//Only Page Editors get View permissions if "Page Editors Only"
continue;
}
ModulePermissionInfo objModulePermission = AddModulePermission(objModule,
objSystemModulePermission,
objTabPermission.RoleID,
objTabPermission.UserID,
objTabPermission.AllowAccess);
// ensure that every EDIT permission which allows access also provides VIEW permission
if (objModulePermission.PermissionKey == "EDIT" & objModulePermission.AllowAccess)
{
ModulePermissionInfo objModuleViewperm = AddModulePermission(objModule,
(PermissionInfo) arrSystemModuleViewPermissions[0],
objModulePermission.RoleID,
objModulePermission.UserID,
true);
}
}
}
objModule.AllTabs = false;
objModule.Alignment = align;
return objModules.AddModule(objModule);
}
return -1;
}
/// <summary>
/// Initializes a new instance of the <see cref="PermissionController"/> class.
/// </summary>
public PermissionController()
{
this.permissionController = new DotNetNuke.Security.Permissions.PermissionController();
}
public ActionResult Save(int folderid, bool Copyfolder, dynamic Data)
{
ActionResult actionResult = new ActionResult();
IFolderInfo parentFolder = FolderManager.Instance.GetFolder(folderid);
if (parentFolder != null)
{
parentFolder.FolderPermissions.Clear();
DotNetNuke.Security.Permissions.PermissionController permController = new DotNetNuke.Security.Permissions.PermissionController();
ArrayList permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "READ");
List <PermissionInfo> SYS_FOLDER_PERM = new List <PermissionInfo>();
if (permArray.Count == 1)
{
SYS_FOLDER_PERM.Add(permArray[0] as PermissionInfo);
}
permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "BROWSE");
if (permArray.Count == 1)
{
SYS_FOLDER_PERM.Add(permArray[0] as PermissionInfo);
}
permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "WRITE");
if (permArray.Count == 1)
{
SYS_FOLDER_PERM.Add(permArray[0] as PermissionInfo);
}
foreach (dynamic item in Data.PermissionsRoles)
{
foreach (dynamic p in item.Permissions)
{
bool AllowAcess = bool.Parse(p.AllowAccess.ToString());
string PermissionID = p.PermissionId.ToString();
if (AllowAcess)
{
FolderPermissionInfo folderpermissioninfo = new FolderPermissionInfo
{
AllowAccess = AllowAcess,
PermissionID = Convert.ToInt32(PermissionID)
};
PermissionInfo SYS_PERM = SYS_FOLDER_PERM.Where(a => a.PermissionID == folderpermissioninfo.PermissionID).FirstOrDefault();
if (SYS_PERM != null)
{
folderpermissioninfo.PermissionKey = SYS_PERM.PermissionKey;
}
folderpermissioninfo.RoleID = int.Parse(item.RoleId.ToString());
parentFolder.FolderPermissions.Add(folderpermissioninfo);
}
}
}
foreach (dynamic item in Data.PermissionsUsers)
{
foreach (dynamic p in item.Permissions)
{
bool AllowAcess = bool.Parse(p.AllowAccess.ToString());
string PermissionID = p.PermissionId.ToString();
if (AllowAcess)
{
FolderPermissionInfo folderpermissioninfo = new FolderPermissionInfo
{
AllowAccess = AllowAcess,
PermissionID = Convert.ToInt32(PermissionID)
};
PermissionInfo SYS_PERM = SYS_FOLDER_PERM.Where(a => a.PermissionID == folderpermissioninfo.PermissionID).FirstOrDefault();
if (SYS_PERM != null)
{
folderpermissioninfo.PermissionKey = SYS_PERM.PermissionKey;
}
folderpermissioninfo.UserID = int.Parse(item.UserId.ToString());
parentFolder.FolderPermissions.Add(folderpermissioninfo);
}
}
}
FolderManager.Instance.UpdateFolder(parentFolder);
if (Copyfolder)
{
FolderPermissionController.CopyPermissionsToSubfolders(parentFolder, parentFolder.FolderPermissions);
}
}
Dictionary <int, bool> result = new Dictionary <int, bool>();
if (Data != null && Data.FolderIds != null && Data.FolderIds.Count > 0)
{
foreach (dynamic id in Data.FolderIds)
{
result.Add(int.Parse(id.Value), BrowseUploadFactory.HasBrowseOpenPerm(new Vanjaro.Common.Components.TreeView()
{
Value = int.Parse(id.Value)
}));
}
}
actionResult.Data = result;
return(actionResult);
}
private void AddFolderPermissions(int portalId, int folderId)
{
var objPortal = GetPortal(portalId);
FolderPermissionInfo objFolderPermission;
var folderManager = FolderManager.Instance;
var folder = folderManager.GetFolder(folderId);
var objPermissionController = new PermissionController();
foreach (PermissionInfo objpermission in objPermissionController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", ""))
{
objFolderPermission = new FolderPermissionInfo(objpermission)
{
FolderID = folder.FolderID,
RoleID = objPortal.AdministratorRoleId,
AllowAccess = true
};
folder.FolderPermissions.Add(objFolderPermission);
if (objpermission.PermissionKey == "READ")
{
//add READ permissions to the All Users Role
folderManager.AddAllUserReadPermission(folder, objpermission);
}
}
FolderPermissionController.SaveFolderPermissions((FolderInfo)folder);
}
private static void ParsePortalDesktopModules(XPathNavigator nav, int portalID)
{
string friendlyName = Null.NullString;
DesktopModuleInfo desktopModule = null;
foreach (XPathNavigator desktopModuleNav in nav.Select("portalDesktopModule"))
{
friendlyName = XmlUtils.GetNodeValue(desktopModuleNav, "friendlyname");
if (!string.IsNullOrEmpty(friendlyName))
{
desktopModule = DesktopModuleController.GetDesktopModuleByFriendlyName(friendlyName);
if (desktopModule != null)
{
//Parse the permissions
DesktopModulePermissionCollection permissions = new DesktopModulePermissionCollection();
foreach (XPathNavigator permissionNav in
desktopModuleNav.Select("portalDesktopModulePermissions/portalDesktopModulePermission"))
{
string code = XmlUtils.GetNodeValue(permissionNav, "permissioncode");
string key = XmlUtils.GetNodeValue(permissionNav, "permissionkey");
DesktopModulePermissionInfo desktopModulePermission = null;
ArrayList arrPermissions = new PermissionController().GetPermissionByCodeAndKey(code, key);
if (arrPermissions.Count > 0)
{
PermissionInfo permission = arrPermissions[0] as PermissionInfo;
if (permission != null)
{
desktopModulePermission = new DesktopModulePermissionInfo(permission);
}
}
desktopModulePermission.AllowAccess = bool.Parse(XmlUtils.GetNodeValue(permissionNav, "allowaccess"));
string rolename = XmlUtils.GetNodeValue(permissionNav, "rolename");
if (!string.IsNullOrEmpty(rolename))
{
RoleInfo role = TestableRoleController.Instance.GetRole(portalID, r => r.RoleName == rolename);
if (role != null)
{
desktopModulePermission.RoleID = role.RoleID;
}
}
permissions.Add(desktopModulePermission);
}
DesktopModuleController.AddDesktopModuleToPortal(portalID, desktopModule, permissions, false);
}
}
}
}
private static void ParseFolderPermissions(XmlNodeList nodeFolderPermissions, int portalId, FolderInfo folder)
{
PermissionController permissionController = new PermissionController();
int permissionId = 0;
//Clear the current folder permissions
folder.FolderPermissions.Clear();
foreach (XmlNode xmlFolderPermission in nodeFolderPermissions)
{
string permissionKey = XmlUtils.GetNodeValue(xmlFolderPermission.CreateNavigator(), "permissionkey");
string permissionCode = XmlUtils.GetNodeValue(xmlFolderPermission.CreateNavigator(), "permissioncode");
string roleName = XmlUtils.GetNodeValue(xmlFolderPermission.CreateNavigator(), "rolename");
bool allowAccess = XmlUtils.GetNodeValueBoolean(xmlFolderPermission, "allowaccess");
foreach (PermissionInfo permission in permissionController.GetPermissionByCodeAndKey(permissionCode, permissionKey))
{
permissionId = permission.PermissionID;
}
int roleId = int.MinValue;
switch (roleName)
{
case Globals.glbRoleAllUsersName:
roleId = Convert.ToInt32(Globals.glbRoleAllUsers);
break;
case Globals.glbRoleUnauthUserName:
roleId = Convert.ToInt32(Globals.glbRoleUnauthUser);
break;
default:
RoleInfo objRole = TestableRoleController.Instance.GetRole(portalId, r => r.RoleName == roleName);
if (objRole != null)
{
roleId = objRole.RoleID;
}
break;
}
//if role was found add, otherwise ignore
if (roleId != int.MinValue)
{
var folderPermission = new FolderPermissionInfo
{
FolderID = folder.FolderID,
PermissionID = permissionId,
RoleID = roleId,
UserID = Null.NullInteger,
AllowAccess = allowAccess
};
bool canAdd = !folder.FolderPermissions.Cast<FolderPermissionInfo>()
.Any(fp => fp.FolderID == folderPermission.FolderID
&& fp.PermissionID == folderPermission.PermissionID
&& fp.RoleID == folderPermission.RoleID
&& fp.UserID == folderPermission.UserID);
if (canAdd)
{
folder.FolderPermissions.Add(folderPermission);
}
}
}
FolderPermissionController.SaveFolderPermissions(folder);
}
/// <summary>
/// Parses folder permissions
/// </summary>
/// <param name="nodeFolderPermissions">Node for folder permissions</param>
/// <param name="PortalID">PortalId of new portal</param>
/// <param name="FolderId">FolderId of folder being processed</param>
/// <history>
/// [cnurse] 11/09/2004 Created
/// </history>
private void ParseFolderPermissions( XmlNodeList nodeFolderPermissions, int PortalID, int FolderId, string folderPath )
{
FolderPermissionCollection objFolderPermissions = new FolderPermissionCollection();
PermissionController objPermissionController = new PermissionController();
PermissionInfo objPermission = null;
FolderPermissionController objFolderPermissionController = new FolderPermissionController();
RoleController objRoleController = new RoleController();
RoleInfo objRole = null;
int RoleID = 0;
int PermissionID = 0;
string PermissionKey = null;
string PermissionCode = null;
string RoleName = null;
bool AllowAccess = false;
ArrayList arrPermissions = null;
int i = 0;
foreach( XmlNode xmlFolderPermission in nodeFolderPermissions )
{
PermissionKey = XmlUtils.GetNodeValue( xmlFolderPermission, "permissionkey", "" );
PermissionCode = XmlUtils.GetNodeValue( xmlFolderPermission, "permissioncode", "" );
RoleName = XmlUtils.GetNodeValue( xmlFolderPermission, "rolename", "" );
AllowAccess = XmlUtils.GetNodeValueBoolean( xmlFolderPermission, "allowaccess", false );
arrPermissions = objPermissionController.GetPermissionByCodeAndKey( PermissionCode, PermissionKey );
for( i = 0; i < arrPermissions.Count; i++ )
{
objPermission = (PermissionInfo)( arrPermissions[i] );
PermissionID = objPermission.PermissionID;
}
RoleID = int.MinValue;
if( RoleName == Globals.glbRoleAllUsersName )
{
RoleID = Convert.ToInt32( Globals.glbRoleAllUsers );
}
else if( RoleName == Globals.glbRoleUnauthUserName )
{
RoleID = Convert.ToInt32( Globals.glbRoleUnauthUser );
}
else
{
objRole = objRoleController.GetRoleByName( PortalID, RoleName );
if( objRole != null )
{
RoleID = objRole.RoleID;
}
}
// if role was found add, otherwise ignore
if( RoleID != int.MinValue )
{
if( AllowAccess )
{
FileSystemUtils.SetFolderPermission( PortalID, FolderId, PermissionID, RoleID, folderPath );
}
}
}
}
private void ParseModulePermissions( XmlNodeList nodeModulePermissions, int PortalId, int ModuleID )
{
RoleController objRoleController = new RoleController();
RoleInfo objRole = null;
ModulePermissionCollection objModulePermissions = new ModulePermissionCollection();
ModulePermissionController objModulePermissionController = new ModulePermissionController();
PermissionController objPermissionController = new PermissionController();
PermissionInfo objPermission = null;
ModulePermissionCollection objModulePermissionCollection = new ModulePermissionCollection();
int PermissionID = 0;
ArrayList arrPermissions = null;
int i = 0;
string PermissionKey = null;
string PermissionCode = null;
string RoleName = null;
int RoleID = 0;
bool AllowAccess = false;
foreach( XmlNode node in nodeModulePermissions )
{
PermissionKey = XmlUtils.GetNodeValue( node, "permissionkey", "" );
PermissionCode = XmlUtils.GetNodeValue( node, "permissioncode", "" );
RoleName = XmlUtils.GetNodeValue( node, "rolename", "" );
AllowAccess = XmlUtils.GetNodeValueBoolean( node, "allowaccess", false );
RoleID = int.MinValue;
if( RoleName == Globals.glbRoleAllUsersName )
{
RoleID = Convert.ToInt32( Globals.glbRoleAllUsers );
}
else if( RoleName == Globals.glbRoleUnauthUserName )
{
RoleID = Convert.ToInt32( Globals.glbRoleUnauthUser );
}
else
{
objRole = objRoleController.GetRoleByName( PortalId, RoleName );
if( objRole != null )
{
RoleID = objRole.RoleID;
}
}
if( RoleID != int.MinValue )
{
PermissionID = -1;
arrPermissions = objPermissionController.GetPermissionByCodeAndKey( PermissionCode, PermissionKey );
for( i = 0; i < arrPermissions.Count; i++ )
{
objPermission = (PermissionInfo)( arrPermissions[i] );
PermissionID = objPermission.PermissionID;
}
// if role was found add, otherwise ignore
if( PermissionID != -1 )
{
ModulePermissionInfo objModulePermission = new ModulePermissionInfo();
objModulePermission.ModuleID = ModuleID;
objModulePermission.PermissionID = PermissionID;
objModulePermission.RoleID = RoleID;
objModulePermission.AllowAccess = Convert.ToBoolean( XmlUtils.GetNodeValue( node, "allowaccess", "false" ) );
objModulePermissionController.AddModulePermission( objModulePermission );
}
}
}
}
/// <summary>
/// Sets a Folders Permissions
/// </summary>
/// <param name="PortalId">The Id of the Portal</param>
/// <param name="FolderId">The Id of the Folder</param>
/// <param name="AdministratorRoleId">The Id of the Administrator Role</param>
/// <param name="relativePath">The folder's Relative Path</param>
/// <remarks>
/// </remarks>
public static void SetFolderPermissions( int PortalId, int FolderId, int AdministratorRoleId, string relativePath )
{
//Set Permissions
PermissionController objPermissionController = new PermissionController();
ArrayList Permissions = objPermissionController.GetPermissionsByFolder( PortalId, "" );
foreach( PermissionInfo objPermssionsInfo in Permissions )
{
SetFolderPermission( PortalId, FolderId, objPermssionsInfo.PermissionID, AdministratorRoleId, relativePath );
}
}
private static void DeserializeModulePermissions(XmlNodeList nodeModulePermissions, int portalId, ModuleInfo module)
{
var permissionController = new PermissionController();
foreach (XmlNode node in nodeModulePermissions)
{
string permissionKey = XmlUtils.GetNodeValue(node.CreateNavigator(), "permissionkey");
string permissionCode = XmlUtils.GetNodeValue(node.CreateNavigator(), "permissioncode");
string roleName = XmlUtils.GetNodeValue(node.CreateNavigator(), "rolename");
int roleID = int.MinValue;
switch (roleName)
{
case Globals.glbRoleAllUsersName:
roleID = Convert.ToInt32(Globals.glbRoleAllUsers);
break;
case Globals.glbRoleUnauthUserName:
roleID = Convert.ToInt32(Globals.glbRoleUnauthUser);
break;
default:
var role = TestableRoleController.Instance.GetRole(portalId, r => r.RoleName == roleName);
if (role != null)
{
roleID = role.RoleID;
}
break;
}
if (roleID != int.MinValue)
{
int permissionID = -1;
ArrayList permissions = permissionController.GetPermissionByCodeAndKey(permissionCode, permissionKey);
for (int i = 0; i <= permissions.Count - 1; i++)
{
var permission = (PermissionInfo)permissions[i];
permissionID = permission.PermissionID;
}
//if role was found add, otherwise ignore
if (permissionID != -1)
{
var modulePermission = new ModulePermissionInfo
{
ModuleID = module.ModuleID,
PermissionID = permissionID,
RoleID = roleID,
AllowAccess = Convert.ToBoolean(XmlUtils.GetNodeValue(node.CreateNavigator(), "allowaccess"))
};
// do not add duplicate ModulePermissions
bool canAdd = !module.ModulePermissions.Cast<ModulePermissionInfo>()
.Any(mp => mp.ModuleID == modulePermission.ModuleID
&& mp.PermissionID == modulePermission.PermissionID
&& mp.RoleID == modulePermission.RoleID
&& mp.UserID == modulePermission.UserID);
if (canAdd)
{
module.ModulePermissions.Add(modulePermission);
}
}
}
}
}
private int DoAddExistingModule(int moduleId, int tabId, string paneName, int position, string align, bool cloneModule)
{
var moduleCtrl = new ModuleController();
ModuleInfo moduleInfo = moduleCtrl.GetModule(moduleId, tabId, false);
int userID = -1;
UserInfo user = UserController.GetCurrentUserInfo();
if (user != null)
{
userID = user.UserID;
}
if ((moduleInfo != null))
{
// Is this from a site other than our own? (i.e., is the user requesting "module sharing"?)
var remote = moduleInfo.PortalID != PortalSettings.Current.PortalId;
if (remote)
{
switch (moduleInfo.DesktopModule.Shareable)
{
case ModuleSharing.Unsupported:
// Should never happen since the module should not be listed in the first place.
throw new ApplicationException(string.Format("Module '{0}' does not support Shareable and should not be listed in Add Existing Module from a different source site",
moduleInfo.DesktopModule.FriendlyName));
case ModuleSharing.Supported:
break;
case ModuleSharing.Unknown:
break;
}
}
// clone the module object ( to avoid creating an object reference to the data cache )
ModuleInfo newModule = moduleInfo.Clone();
newModule.UniqueId = Guid.NewGuid(); // Cloned Module requires a different uniqueID
newModule.TabID = PortalSettings.Current.ActiveTab.TabID;
newModule.ModuleOrder = position;
newModule.PaneName = paneName;
newModule.Alignment = align;
if ((cloneModule))
{
newModule.ModuleID = Null.NullInteger;
//reset the module id
newModule.ModuleID = moduleCtrl.AddModule(newModule);
if (!string.IsNullOrEmpty(newModule.DesktopModule.BusinessControllerClass))
{
object objObject = DotNetNuke.Framework.Reflection.CreateObject(newModule.DesktopModule.BusinessControllerClass, newModule.DesktopModule.BusinessControllerClass);
if (objObject is IPortable)
{
string content = Convert.ToString(((IPortable)objObject).ExportModule(moduleId));
if (!string.IsNullOrEmpty(content))
{
((IPortable)objObject).ImportModule(newModule.ModuleID, content, newModule.DesktopModule.Version, userID);
}
}
}
}
else
{
moduleCtrl.AddModule(newModule);
}
if (remote)
{
//Ensure the Portal Admin has View rights
var permissionController = new PermissionController();
ArrayList arrSystemModuleViewPermissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "VIEW");
AddModulePermission(newModule,
(PermissionInfo)arrSystemModuleViewPermissions[0],
PortalSettings.Current.AdministratorRoleId,
Null.NullInteger,
true);
//Set PortalID correctly
newModule.OwnerPortalID = newModule.PortalID;
newModule.PortalID = PortalSettings.Current.PortalId;
ModulePermissionController.SaveModulePermissions(newModule);
}
//Add Event Log
var objEventLog = new EventLogController();
objEventLog.AddLog(newModule, PortalSettings.Current, userID, "", EventLogController.EventLogType.MODULE_CREATED);
return newModule.ModuleID;
}
return -1;
}
protected void OnImportClick(object sender, EventArgs e)
{
try
{
if (cboTemplate.SelectedItem == null || cboTemplate.SelectedValue == "None_Specified")
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("SpecifyFile", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
return;
}
if (optMode.SelectedIndex == -1)
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("SpecifyMode", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
return;
}
var xmlDoc = new XmlDocument();
xmlDoc.Load(PortalSettings.HomeDirectoryMapPath + cboFolders.SelectedValue + cboTemplate.SelectedValue);
var tabNodes = new List<XmlNode>();
foreach (XmlNode tabNode in xmlDoc.SelectSingleNode("//portal/tabs").ChildNodes)
{
tabNodes.Add(tabNode);
}
if (tabNodes.Count == 0)
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("NoTabsInTemplate", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
return;
}
TabInfo objTab;
if (optMode.SelectedValue == "ADD")
{
if (string.IsNullOrEmpty(txtTabName.Text))
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("SpecifyName", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
return;
}
//New Tab
objTab = new TabInfo {PortalID = PortalId, TabName = txtTabName.Text, IsVisible = true};
if (cboParentTab.SelectedItem != null)
{
objTab.ParentId = Int32.Parse(cboParentTab.SelectedItem.Value);
}
objTab.TabPath = Globals.GenerateTabPath(objTab.ParentId, objTab.TabName);
int tabID = TabController.GetTabByTabPath(objTab.PortalID, objTab.TabPath, Null.NullString);
var objTabs = new TabController();
//Check if tab exists
if (tabID != Null.NullInteger)
{
TabInfo existingTab = objTabs.GetTab(tabID, PortalId, false);
if (existingTab != null && existingTab.IsDeleted)
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("TabRecycled", LocalResourceFile), ModuleMessage.ModuleMessageType.YellowWarning);
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("TabExists", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
}
return;
}
int positionTabID = Int32.Parse(cboPositionTab.SelectedItem.Value);
var pc = new PermissionController();
var permission = pc.GetPermissionByCodeAndKey("SYSTEM_TAB", "VIEW");
if (permission.Count > 0)
{
var pid = ((PermissionInfo)permission[0]).PermissionID;
objTab.TabPermissions.Add(new TabPermissionInfo { PermissionID = pid, AllowAccess = true, RoleID = 0 });
}
permission = pc.GetPermissionByCodeAndKey("SYSTEM_TAB", "EDIT");
if (permission.Count > 0)
{
var pid = ((PermissionInfo)permission[0]).PermissionID;
objTab.TabPermissions.Add(new TabPermissionInfo { PermissionID = pid, AllowAccess = true, RoleID = 0 });
}
var objEventLog = new EventLogController();
if (rbInsertPosition.SelectedValue == "After" && positionTabID > Null.NullInteger)
{
objTab.TabID = objTabs.AddTabAfter(objTab, positionTabID);
}
else if (rbInsertPosition.SelectedValue == "Before" && positionTabID > Null.NullInteger)
{
objTab.TabID = objTabs.AddTabBefore(objTab, positionTabID);
}
else
{
objTab.TabID = objTabs.AddTab(objTab);
}
objEventLog.AddLog(objTab, PortalSettings, UserId, "", EventLogController.EventLogType.TAB_CREATED);
//Update Tab properties from template - for the first tab only
objTab = TabController.DeserializeTab(tabNodes[0], objTab, PortalId, PortalTemplateModuleAction.Replace);
var exceptions = string.Empty;
//Create second tabs onwards. For firs tab, we like to use tab details from text box, for rest it'll come from template
for(var tab=1; tab < tabNodes.Count; tab++)
{
try
{
TabController.DeserializeTab(tabNodes[tab], null, PortalId, PortalTemplateModuleAction.Replace);
}
catch (Exception ex)
{
Exceptions.LogException(ex);
exceptions += string.Format("Template Tab # {0}. Error {1}<br/>", tab + 1, ex.Message);
}
}
if(!string.IsNullOrEmpty(exceptions))
{
UI.Skins.Skin.AddModuleMessage(this, exceptions, ModuleMessage.ModuleMessageType.RedError);
return;
}
}
else
{
//Replace Existing Tab
objTab = TabController.DeserializeTab(tabNodes[0], Tab, PortalId, PortalTemplateModuleAction.Replace);
}
switch (optRedirect.SelectedValue)
{
case "VIEW":
Response.Redirect(Globals.NavigateURL(objTab.TabID), true);
break;
default:
Response.Redirect(Globals.NavigateURL(objTab.TabID, "Tab", "action=edit"), true);
break;
}
}
catch (Exception exc)
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
public static void DeserializeTabPermissions(XmlNodeList nodeTabPermissions, TabInfo tab)
{
var permissionController = new PermissionController();
foreach (XmlNode xmlTabPermission in nodeTabPermissions)
{
var permissionKey = XmlUtils.GetNodeValue(xmlTabPermission.CreateNavigator(), "permissionkey");
var permissionCode = XmlUtils.GetNodeValue(xmlTabPermission.CreateNavigator(), "permissioncode");
var roleName = XmlUtils.GetNodeValue(xmlTabPermission.CreateNavigator(), "rolename");
var allowAccess = XmlUtils.GetNodeValueBoolean(xmlTabPermission, "allowaccess");
var permissions = permissionController.GetPermissionByCodeAndKey(permissionCode, permissionKey);
var permissionId = permissions.Cast<PermissionInfo>().Last().PermissionID;
var roleId = int.MinValue;
switch (roleName)
{
case Globals.glbRoleAllUsersName:
roleId = Convert.ToInt32(Globals.glbRoleAllUsers);
break;
case Globals.glbRoleUnauthUserName:
roleId = Convert.ToInt32(Globals.glbRoleUnauthUser);
break;
default:
var portal = PortalController.Instance.GetPortal(tab.PortalID);
var role = RoleController.Instance.GetRole(portal.PortalID, r => r.RoleName == roleName);
if (role != null)
{
roleId = role.RoleID;
}
break;
}
if (roleId != int.MinValue &&
!tab.TabPermissions.Cast<TabPermissionInfo>().Any(p =>
p.RoleID == roleId
&& p.PermissionID == permissionId))
{
var tabPermission = new TabPermissionInfo
{
TabID = tab.TabID,
PermissionID = permissionId,
RoleID = roleId,
AllowAccess = allowAccess
};
tab.TabPermissions.Add(tabPermission);
}
}
TabController.Instance.UpdateTab(tab);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Adds a New Module to a Pane
/// </summary>
/// <param name="align">The alignment for the Modue</param>
/// <param name="desktopModuleId">The Id of the DesktopModule</param>
/// <param name="permissionType">The View Permission Type for the Module</param>
/// <param name="title">The Title for the resulting module</param>
/// <param name="paneName">The pane to add the module to</param>
/// <param name="position">The relative position within the pane for the module</param>
/// <history>
/// [cnurse] 01/11/2008 documented
/// </history>
/// -----------------------------------------------------------------------------
protected void AddNewModule(string title, int desktopModuleId, string paneName, int position, ViewPermissionType permissionType, string align)
{
TabPermissionCollection objTabPermissions = PortalSettings.ActiveTab.TabPermissions;
var objPermissionController = new PermissionController();
try
{
DesktopModuleInfo desktopModule;
if (!DesktopModuleController.GetDesktopModules(PortalSettings.PortalId).TryGetValue(desktopModuleId, out desktopModule))
{
throw new ArgumentException("desktopModuleId");
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
}
int UserId = -1;
if (Request.IsAuthenticated)
{
UserInfo objUserInfo = UserController.Instance.GetCurrentUserInfo();
UserId = objUserInfo.UserID;
}
foreach (ModuleDefinitionInfo objModuleDefinition in
ModuleDefinitionController.GetModuleDefinitionsByDesktopModuleID(desktopModuleId).Values)
{
var objModule = new ModuleInfo();
objModule.Initialize(PortalSettings.PortalId);
objModule.PortalID = PortalSettings.PortalId;
objModule.TabID = PortalSettings.ActiveTab.TabID;
objModule.ModuleOrder = position;
if (String.IsNullOrEmpty(title))
{
objModule.ModuleTitle = objModuleDefinition.FriendlyName;
}
else
{
objModule.ModuleTitle = title;
}
objModule.PaneName = paneName;
objModule.ModuleDefID = objModuleDefinition.ModuleDefID;
if (objModuleDefinition.DefaultCacheTime > 0)
{
objModule.CacheTime = objModuleDefinition.DefaultCacheTime;
if (PortalSettings.Current.DefaultModuleId > Null.NullInteger && PortalSettings.Current.DefaultTabId > Null.NullInteger)
{
ModuleInfo defaultModule = ModuleController.Instance.GetModule(PortalSettings.Current.DefaultModuleId, PortalSettings.Current.DefaultTabId, true);
if (defaultModule != null)
{
objModule.CacheTime = defaultModule.CacheTime;
}
}
}
switch (permissionType)
{
case ViewPermissionType.View:
objModule.InheritViewPermissions = true;
break;
case ViewPermissionType.Edit:
objModule.InheritViewPermissions = false;
break;
}
//get the default module view permissions
ArrayList arrSystemModuleViewPermissions = objPermissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "VIEW");
//get the permissions from the page
foreach (TabPermissionInfo objTabPermission in objTabPermissions)
{
if (objTabPermission.PermissionKey == "VIEW" && permissionType == ViewPermissionType.View)
{
//Don't need to explicitly add View permisisons if "Same As Page"
continue;
}
//get the system module permissions for the permissionkey
ArrayList arrSystemModulePermissions = objPermissionController.GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", objTabPermission.PermissionKey);
//loop through the system module permissions
int j;
for (j = 0; j <= arrSystemModulePermissions.Count - 1; j++)
{
PermissionInfo objSystemModulePermission;
objSystemModulePermission = (PermissionInfo) arrSystemModulePermissions[j];
if (objSystemModulePermission.PermissionKey == "VIEW" && permissionType == ViewPermissionType.Edit && objTabPermission.PermissionKey != "EDIT")
{
//Only Page Editors get View permissions if "Page Editors Only"
continue;
}
ModulePermissionInfo objModulePermission = AddModulePermission(objModule,
objSystemModulePermission,
objTabPermission.RoleID,
objTabPermission.UserID,
objTabPermission.AllowAccess);
//ensure that every EDIT permission which allows access also provides VIEW permission
if (objModulePermission.PermissionKey == "EDIT" && objModulePermission.AllowAccess)
{
ModulePermissionInfo objModuleViewperm = AddModulePermission(objModule,
(PermissionInfo) arrSystemModuleViewPermissions[0],
objModulePermission.RoleID,
objModulePermission.UserID,
true);
}
}
//Get the custom Module Permissions, Assume that roles with Edit Tab Permissions
//are automatically assigned to the Custom Module Permissions
if (objTabPermission.PermissionKey == "EDIT")
{
ArrayList arrCustomModulePermissions = objPermissionController.GetPermissionsByModuleDefID(objModule.ModuleDefID);
//loop through the custom module permissions
for (j = 0; j <= arrCustomModulePermissions.Count - 1; j++)
{
//create the module permission
PermissionInfo objCustomModulePermission;
objCustomModulePermission = (PermissionInfo) arrCustomModulePermissions[j];
AddModulePermission(objModule, objCustomModulePermission, objTabPermission.RoleID, objTabPermission.UserID, objTabPermission.AllowAccess);
}
}
}
if (PortalSettings.Current.ContentLocalizationEnabled)
{
Locale defaultLocale = LocaleController.Instance.GetDefaultLocale(PortalSettings.Current.PortalId);
//set the culture of the module to that of the tab
var tabInfo = TabController.Instance.GetTab(objModule.TabID, PortalSettings.Current.PortalId, false);
objModule.CultureCode = tabInfo != null ? tabInfo.CultureCode : defaultLocale.Code;
}
else
{
objModule.CultureCode = Null.NullString;
}
objModule.AllTabs = false;
objModule.Alignment = align;
ModuleController.Instance.AddModule(objModule);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// SaveModuleDefinition saves the Module Definition to the database
/// </summary>
/// <param name="moduleDefinition">The Module Definition to save</param>
/// <param name="saveChildren">A flag that determines whether the child objects are also saved</param>
/// <param name="clearCache">A flag that determines whether to clear the host cache</param>
/// <history>
/// [cnurse] 01/14/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
public static int SaveModuleDefinition(ModuleDefinitionInfo moduleDefinition, bool saveChildren, bool clearCache)
{
int moduleDefinitionID = moduleDefinition.ModuleDefID;
if (moduleDefinitionID == Null.NullInteger)
{
//Add new Module Definition
moduleDefinitionID = dataProvider.AddModuleDefinition(moduleDefinition.DesktopModuleID,
moduleDefinition.FriendlyName,
moduleDefinition.DefinitionName,
moduleDefinition.DefaultCacheTime,
UserController.Instance.GetCurrentUserInfo().UserID);
}
else
{
//Upgrade Module Definition
dataProvider.UpdateModuleDefinition(moduleDefinition.ModuleDefID, moduleDefinition.FriendlyName, moduleDefinition.DefinitionName, moduleDefinition.DefaultCacheTime, UserController.Instance.GetCurrentUserInfo().UserID);
}
if (saveChildren)
{
foreach (KeyValuePair<string, PermissionInfo> kvp in moduleDefinition.Permissions)
{
kvp.Value.ModuleDefID = moduleDefinitionID;
//check if permission exists
var permissionController = new PermissionController();
ArrayList permissions = permissionController.GetPermissionByCodeAndKey(kvp.Value.PermissionCode, kvp.Value.PermissionKey);
if (permissions != null && permissions.Count == 1)
{
var permission = (PermissionInfo) permissions[0];
kvp.Value.PermissionID = permission.PermissionID;
permissionController.UpdatePermission(kvp.Value);
}
else
{
permissionController.AddPermission(kvp.Value);
}
}
foreach (KeyValuePair<string, ModuleControlInfo> kvp in moduleDefinition.ModuleControls)
{
kvp.Value.ModuleDefID = moduleDefinitionID;
//check if definition exists
ModuleControlInfo moduleControl = ModuleControlController.GetModuleControlByControlKey(kvp.Value.ControlKey, kvp.Value.ModuleDefID);
if (moduleControl != null)
{
kvp.Value.ModuleControlID = moduleControl.ModuleControlID;
}
ModuleControlController.SaveModuleControl(kvp.Value, clearCache);
}
}
if (clearCache)
{
DataCache.ClearHostCache(true);
}
return moduleDefinitionID;
}
public string UpgradeModule(string Version)
{
try
{
switch (Version)
{
case "01.00.00":
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("Messaging");
if (moduleDefinition != null)
{
//Add Module to User Profile Page for all Portals
var objPortalController = new PortalController();
var objTabController = new TabController();
var objModuleController = new ModuleController();
ArrayList portals = objPortalController.GetPortals();
foreach (PortalInfo portal in portals)
{
int tabID = TabController.GetTabByTabPath(portal.PortalID, "//UserProfile", Null.NullString);
if ((tabID != Null.NullInteger))
{
TabInfo tab = objTabController.GetTab(tabID, portal.PortalID, true);
if ((tab != null))
{
int moduleId = Upgrade.AddModuleToPage(tab, moduleDefinition.ModuleDefID, "My Inbox", "", true);
ModuleInfo objModule = objModuleController.GetModule(moduleId, tabID, false);
var settings = new PortalSettings(portal);
var modulePermission = (from ModulePermissionInfo p in objModule.ModulePermissions
where p.ModuleID == moduleId
&& p.RoleID == settings.RegisteredRoleId
&& p.UserID == Null.NullInteger
&& p.PermissionKey == "EDIT"
select p).SingleOrDefault();
if (modulePermission == null)
{
ArrayList permissions = new PermissionController().GetPermissionByCodeAndKey("SYSTEM_MODULE_DEFINITION", "EDIT");
PermissionInfo permission = null;
if (permissions.Count == 1)
{
permission = permissions[0] as PermissionInfo;
}
if (permission != null)
{
modulePermission = new ModulePermissionInfo(permission)
{
ModuleID = moduleId,
RoleID = settings.RegisteredRoleId,
UserID = Null.NullInteger,
AllowAccess = true
};
objModule.ModulePermissions.Add(modulePermission);
ModulePermissionController.SaveModulePermissions(objModule);
}
}
}
}
}
}
break;
}
return "Success";
}
catch (Exception exc)
{
Logger.Error(exc);
return "Failed";
}
}
private static void UpgradeToVersion500()
{
ArrayList portals = PortalController.Instance.GetPortals();
//Add Edit Permissions for Admin Tabs to legacy portals
var permissionController = new PermissionController();
ArrayList permissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_TAB", "EDIT");
int permissionId = -1;
if (permissions.Count == 1)
{
var permission = permissions[0] as PermissionInfo;
if (permission != null)
{
permissionId = permission.PermissionID;
}
foreach (PortalInfo portal in portals)
{
var adminTab = TabController.Instance.GetTab(portal.AdminTabId, portal.PortalID, true);
if (adminTab != null)
{
var tabPermission = new TabPermissionInfo { TabID = adminTab.TabID, PermissionID = permissionId, AllowAccess = true, RoleID = portal.AdministratorRoleId };
if (!TabPermissionExists(tabPermission, portal.PortalID))
{
adminTab.TabPermissions.Add(tabPermission);
}
//Save Tab Permissions to Data Base
TabPermissionController.SaveTabPermissions(adminTab);
foreach (var childTab in TabController.GetTabsByParent(portal.AdminTabId, portal.PortalID))
{
tabPermission = new TabPermissionInfo { TabID = childTab.TabID, PermissionID = permissionId, AllowAccess = true, RoleID = portal.AdministratorRoleId };
if (!TabPermissionExists(tabPermission, portal.PortalID))
{
childTab.TabPermissions.Add(tabPermission);
}
//Save Tab Permissions to Data Base
TabPermissionController.SaveTabPermissions(childTab);
}
}
}
}
//Update Host/Admin modules Visibility setting
bool superTabProcessed = Null.NullBoolean;
foreach (PortalInfo portal in portals)
{
if (!superTabProcessed)
{
//Process Host Tabs
foreach (TabInfo childTab in TabController.GetTabsByParent(portal.SuperTabId, Null.NullInteger))
{
foreach (ModuleInfo tabModule in ModuleController.Instance.GetTabModules(childTab.TabID).Values)
{
tabModule.Visibility = VisibilityState.None;
ModuleController.Instance.UpdateModule(tabModule);
}
}
}
//Process Portal Tabs
foreach (TabInfo childTab in TabController.GetTabsByParent(portal.AdminTabId, portal.PortalID))
{
foreach (ModuleInfo tabModule in ModuleController.Instance.GetTabModules(childTab.TabID).Values)
{
tabModule.Visibility = VisibilityState.None;
ModuleController.Instance.UpdateModule(tabModule);
}
}
}
//Upgrade PortalDesktopModules to support new "model"
permissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_DESKTOPMODULE", "DEPLOY");
if (permissions.Count == 1)
{
var permission = permissions[0] as PermissionInfo;
if (permission != null)
{
permissionId = permission.PermissionID;
}
foreach (PortalInfo portal in portals)
{
foreach (DesktopModuleInfo desktopModule in DesktopModuleController.GetDesktopModules(Null.NullInteger).Values)
{
if (!desktopModule.IsPremium)
{
//Parse the permissions
var deployPermissions = new DesktopModulePermissionCollection();
DesktopModulePermissionInfo deployPermission;
// if Not IsAdmin add Registered Users
if (!desktopModule.IsAdmin)
{
deployPermission = new DesktopModulePermissionInfo { PermissionID = permissionId, AllowAccess = true, RoleID = portal.RegisteredRoleId };
deployPermissions.Add(deployPermission);
}
// if Not a Host Module add Administrators
const string hostModules = "Portals, SQL, HostSettings, Scheduler, SearchAdmin, Lists, SkinDesigner, Extensions";
if (!hostModules.Contains(desktopModule.ModuleName))
{
deployPermission = new DesktopModulePermissionInfo { PermissionID = permissionId, AllowAccess = true, RoleID = portal.AdministratorRoleId };
deployPermissions.Add(deployPermission);
}
//Add Portal/Module to PortalDesktopModules
DesktopModuleController.AddDesktopModuleToPortal(portal.PortalID, desktopModule, deployPermissions, false);
}
}
DataCache.ClearPortalCache(portal.PortalID, true);
}
}
LegacyUtil.ProcessLegacyModules();
LegacyUtil.ProcessLegacyLanguages();
LegacyUtil.ProcessLegacySkins();
LegacyUtil.ProcessLegacySkinControls();
}
/// -----------------------------------------------------------------------------
/// <summary>
/// DeleteModuleDefinition deletes a Module Definition By ID
/// </summary>
/// <param name="moduleDefinitionId">The ID of the Module Definition to delete</param>
/// <history>
/// [cnurse] 01/11/2008 Documented
/// </history>
/// -----------------------------------------------------------------------------
public void DeleteModuleDefinition(int moduleDefinitionId)
{
//Delete associated permissions
var permissionController = new PermissionController();
foreach (PermissionInfo permission in permissionController.GetPermissionsByModuleDefID(moduleDefinitionId))
{
permissionController.DeletePermission(permission.PermissionID);
}
dataProvider.DeleteModuleDefinition(moduleDefinitionId);
DataCache.ClearHostCache(true);
}
private static void AddManageUsersModulePermissions()
{
var permCtl = new PermissionController();
var desktopInfo = DesktopModuleController.GetDesktopModuleByModuleName("Security", Null.NullInteger);
//add new user dialog
var md = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("User Account", desktopInfo.DesktopModuleID);
try
{
var pi = new PermissionInfo
{
ModuleDefID = md.ModuleDefID,
PermissionCode = "SECURITY_MODULE",
PermissionKey = "MANAGEUSER",
PermissionName = "Manage User"
};
permCtl.AddPermission(pi);
}
catch
{
//suppress
}
md = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("User Accounts", desktopInfo.DesktopModuleID);
try
{
var pi = new PermissionInfo
{
ModuleDefID = md.ModuleDefID,
PermissionCode = "SECURITY_MODULE",
PermissionKey = "MANAGEUSERS",
PermissionName = "Manage Users"
};
permCtl.AddPermission(pi);
}
catch
{
//suppress
}
md = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("Security Roles", desktopInfo.DesktopModuleID);
try
{
var pi = new PermissionInfo
{
ModuleDefID = md.ModuleDefID,
PermissionCode = "SECURITY_MODULE",
PermissionKey = "MANAGEROLES",
PermissionName = "Manage Roles"
};
permCtl.AddPermission(pi);
}
catch
{
//suppress
}
}
private static void UpgradeToVersion601()
{
//List module needs to be available to Portals also
var pkg = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.Name == "DotNetNuke.Lists");
if (pkg != null)
{
//List package is no longer a system package
pkg.IsSystemPackage = false;
PackageController.Instance.SaveExtensionPackage(pkg);
//List desktop module is no longer premium or admin module
var desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(pkg.PackageID);
desktopModule.IsAdmin = false;
desktopModule.IsPremium = false;
DesktopModuleController.SaveDesktopModule(desktopModule, false, true);
var permissionController = new PermissionController();
ArrayList permissions = permissionController.GetPermissionByCodeAndKey("SYSTEM_DESKTOPMODULE", "DEPLOY");
if (permissions.Count == 1)
{
var permission = permissions[0] as PermissionInfo;
if (permission != null)
{
foreach (PortalInfo portal in PortalController.Instance.GetPortals())
{
//ensure desktop module is not present in the portal
var pdmi = DesktopModuleController.GetPortalDesktopModule(portal.PortalID, desktopModule.DesktopModuleID);
if (pdmi == null)
{
//Parse the permissions
var deployPermissions = new DesktopModulePermissionCollection();
var deployPermission = new DesktopModulePermissionInfo { PermissionID = permission.PermissionID, AllowAccess = true, RoleID = portal.AdministratorRoleId };
deployPermissions.Add(deployPermission);
//Add Portal/Module to PortalDesktopModules
DesktopModuleController.AddDesktopModuleToPortal(portal.PortalID, desktopModule, deployPermissions, true);
}
}
}
}
}
}
/// <summary>
/// Parses tab permissions
/// </summary>
/// <param name="nodeTabPermissions">Node for tab permissions</param>
/// <param name="objPortal">Portal object of new portal</param>
/// <param name="TabId">TabId of tab being processed</param>
/// <param name="IsAdminTemplate">Flag to indicate if we are parsing admin template</param>
/// <history>
/// [Vicenç] 15/10/2004 Created
/// </history>
private TabPermissionCollection ParseTabPermissions( XmlNodeList nodeTabPermissions, PortalInfo objPortal, int TabId, bool IsAdminTemplate )
{
TabPermissionCollection objTabPermissions = new TabPermissionCollection();
PermissionController objPermissionController = new PermissionController();
PermissionInfo objPermission = null;
TabPermissionInfo objTabPermission = null;
RoleController objRoleController = new RoleController();
RoleInfo objRole = null;
int RoleID = 0;
int PermissionID = 0;
string PermissionKey = null;
string PermissionCode = null;
string RoleName = null;
bool AllowAccess = false;
ArrayList arrPermissions = null;
int i = 0;
foreach( XmlNode xmlTabPermission in nodeTabPermissions )
{
PermissionKey = XmlUtils.GetNodeValue( xmlTabPermission, "permissionkey", "" );
PermissionCode = XmlUtils.GetNodeValue( xmlTabPermission, "permissioncode", "" );
RoleName = XmlUtils.GetNodeValue( xmlTabPermission, "rolename", "" );
AllowAccess = XmlUtils.GetNodeValueBoolean( xmlTabPermission, "allowaccess", false );
arrPermissions = objPermissionController.GetPermissionByCodeAndKey( PermissionCode, PermissionKey );
for( i = 0; i < arrPermissions.Count; i++ )
{
objPermission = (PermissionInfo)( arrPermissions[i] );
PermissionID = objPermission.PermissionID;
}
RoleID = int.MinValue;
if( RoleName == Globals.glbRoleAllUsersName )
{
RoleID = Convert.ToInt32( Globals.glbRoleAllUsers );
}
else if( RoleName == Globals.glbRoleUnauthUserName )
{
RoleID = Convert.ToInt32( Globals.glbRoleUnauthUser );
}
else
{
objRole = objRoleController.GetRoleByName( objPortal.PortalID, RoleName );
if( objRole != null )
{
RoleID = objRole.RoleID;
}
else
{
// if parsing admin.template and role administrators redefined, use portal.administratorroleid
if( IsAdminTemplate && RoleName.ToLower() == "administrators" )
{
RoleID = objPortal.AdministratorRoleId;
}
}
}
// if role was found add, otherwise ignore
if( RoleID != int.MinValue )
{
objTabPermission = new TabPermissionInfo();
objTabPermission.TabID = TabId;
objTabPermission.PermissionID = PermissionID;
objTabPermission.RoleID = RoleID;
objTabPermission.AllowAccess = AllowAccess;
objTabPermissions.Add( objTabPermission );
}
}
return objTabPermissions;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// AddPagePermission adds a TabPermission to a TabPermission Collection
/// </summary>
/// <param name="permissions">Page Permissions Collection for this page</param>
/// <param name="key">The Permission key</param>
/// <param name="roleId">The role given the permission</param>
/// <history>
/// [cnurse] 11/11/2004 created
/// </history>
/// -----------------------------------------------------------------------------
private static void AddPagePermission(TabPermissionCollection permissions, string key, int roleId)
{
DnnInstallLogger.InstallLogInfo(Localization.Localization.GetString("LogStart", Localization.Localization.GlobalResourceFile) + "AddPagePermission:" + key);
var permissionController = new PermissionController();
var permission = (PermissionInfo)permissionController.GetPermissionByCodeAndKey("SYSTEM_TAB", key)[0];
var tabPermission = new TabPermissionInfo { PermissionID = permission.PermissionID, RoleID = roleId, AllowAccess = true };
permissions.Add(tabPermission);
}
/// <summary>
/// Processess a template file for the new portal. This method will be called twice: for the portal template and for the admin template
/// </summary>
/// <param name="PortalId">PortalId of the new portal</param>
/// <param name="TemplatePath">Path for the folder where templates are stored</param>
/// <param name="TemplateFile">Template file to process</param>
/// <param name="AdministratorId">UserId for the portal administrator. This is used to assign roles to this user</param>
/// <param name="mergeTabs">Flag to determine whether Module content is merged.</param>
/// <param name="IsNewPortal">Flag to determine is the template is applied to an existing portal or a new one.</param>
/// <remarks>
/// The roles and settings nodes will only be processed on the portal template file.
/// </remarks>
/// <history>
/// [VMasanas] 27/08/2004 Created
/// </history>
public void ParseTemplate( int PortalId, string TemplatePath, string TemplateFile, int AdministratorId, PortalTemplateModuleAction mergeTabs, bool IsNewPortal )
{
XmlDocument xmlDoc = new XmlDocument();
XmlNode node = null;
int AdministratorRoleId = -1;
int RegisteredRoleId = -1;
int SubscriberRoleId = -1;
RoleController objrole = new RoleController();
bool isAdminTemplate = false;
isAdminTemplate = ( TemplateFile == "admin.template" );
// open the XML file
try
{
xmlDoc.Load( TemplatePath + TemplateFile );
}
catch // error
{
//
}
// settings, roles, folders and files can only be specified in portal templates, will be ignored on the admin template
if( !isAdminTemplate )
{
// parse roles if available
node = xmlDoc.SelectSingleNode( "//portal/roles" );
if( node != null )
{
ParseRoles( node, PortalId, AdministratorId, ref AdministratorRoleId, ref RegisteredRoleId, ref SubscriberRoleId );
}
// create required roles if not already created
if( AdministratorRoleId == -1 )
{
AdministratorRoleId = CreateRole( PortalId, "Administrators", "Portal Administrators", 0F, 0, "M", 0F, 0, "N", false, false );
}
if( RegisteredRoleId == -1 )
{
RegisteredRoleId = CreateRole( PortalId, "Registered Users", "Registered Users", 0F, 0, "M", 0F, 0, "N", false, true );
}
if( SubscriberRoleId == -1 )
{
SubscriberRoleId = CreateRole( PortalId, "Subscribers", "A public role for portal subscriptions", 0F, 0, "M", 0F, 0, "N", true, true );
}
objrole.AddUserRole( PortalId, AdministratorId, AdministratorRoleId, Null.NullDate, Null.NullDate );
objrole.AddUserRole( PortalId, AdministratorId, RegisteredRoleId, Null.NullDate, Null.NullDate );
objrole.AddUserRole( PortalId, AdministratorId, SubscriberRoleId, Null.NullDate, Null.NullDate );
// parse portal folders
node = xmlDoc.SelectSingleNode( "//portal/folders" );
if( node != null )
{
ParseFolders( node, PortalId );
}
// force creation of root folder if not present on template
FolderController objController = new FolderController();
if( objController.GetFolder( PortalId, "" ) == null )
{
int folderid = objController.AddFolder( PortalId, "", (int)FolderController.StorageLocationTypes.InsecureFileSystem, true, false );
PermissionController objPermissionController = new PermissionController();
ArrayList arr = objPermissionController.GetPermissionByCodeAndKey( "SYSTEM_FOLDER", "" );
foreach( PermissionInfo objpermission in arr )
{
FileSystemUtils.SetFolderPermission( PortalId, folderid, objpermission.PermissionID, AdministratorRoleId, "" );
if( objpermission.PermissionKey == "READ" )
{
// add READ permissions to the All Users Role
FileSystemUtils.SetFolderPermission( PortalId, folderid, objpermission.PermissionID, int.Parse( Globals.glbRoleAllUsers ), "" );
}
}
}
// parse portal settings if available only for new portals
node = xmlDoc.SelectSingleNode( "//portal/settings" );
if( node != null & IsNewPortal )
{
ParsePortalSettings( node, PortalId );
}
// update portal setup
PortalInfo objportal = null;
objportal = GetPortal( PortalId );
UpdatePortalSetup( PortalId, AdministratorId, AdministratorRoleId, RegisteredRoleId, objportal.SplashTabId, objportal.HomeTabId, objportal.LoginTabId, objportal.UserTabId, objportal.AdminTabId );
//Remove Exising Tabs if doing a "Replace"
if( mergeTabs == PortalTemplateModuleAction.Replace )
{
TabController objTabs = new TabController();
TabInfo objTab = null;
foreach( KeyValuePair<int, TabInfo> tabPair in objTabs.GetTabsByPortal( PortalId ) )
{
objTab = tabPair.Value;
if( !objTab.IsAdminTab )
{
//soft delete Tab
objTab.TabName = objTab.TabName + "_old";
objTab.IsDeleted = true;
objTabs.UpdateTab( objTab );
//Delete all Modules
ModuleController objModules = new ModuleController();
ModuleInfo objModule = null;
foreach( KeyValuePair<int, ModuleInfo> modulePair in objModules.GetTabModules( objTab.TabID ) )
{
objModule = modulePair.Value;
objModules.DeleteTabModule( objModule.TabID, objModule.ModuleID );
}
}
}
}
}
// parse portal tabs
node = xmlDoc.SelectSingleNode( "//portal/tabs" );
if( node != null )
{
ParseTabs( node, PortalId, isAdminTemplate, mergeTabs, IsNewPortal );
}
}