private static void LogEvent(PortalAliasInfo portalAlias, EventLogController.EventLogType logType)
{
int userId = UserController.GetCurrentUserInfo().UserID;
var eventLogController = new EventLogController();
eventLogController.AddLog(portalAlias, PortalController.GetCurrentPortalSettings(), userId, "", logType);
}
/// <summary>
/// Gets the portal settings.
/// </summary>
/// <returns>
/// The Portal Settings.
/// </returns>
private PortalSettings GetPortalSettings()
{
int iTabId = 0, iPortalId = 0;
PortalSettings portalSettings;
try
{
if (this.request.QueryString["tabid"] != null)
{
iTabId = int.Parse(this.request.QueryString["tabid"]);
}
if (this.request.QueryString["PortalID"] != null)
{
iPortalId = int.Parse(this.request.QueryString["PortalID"]);
}
string sDomainName = Globals.GetDomainName(this.Request, true);
string sPortalAlias = PortalAliasController.GetPortalAliasByPortal(iPortalId, sDomainName);
PortalAliasInfo objPortalAliasInfo = PortalAliasController.Instance.GetPortalAlias(sPortalAlias);
portalSettings = new PortalSettings(iTabId, objPortalAliasInfo);
}
catch (Exception)
{
portalSettings = (PortalSettings)HttpContext.Current.Items["PortalSettings"];
}
return(portalSettings);
}
public static ActionResult GetSiteAlias(UserInfo userInfo, int portalAliasId)
{
ActionResult actionResult = new ActionResult();
try
{
PortalAliasInfo alias = PortalAliasController.Instance.GetPortalAliasByPortalAliasID(portalAliasId);
if (!userInfo.IsSuperUser && alias.PortalID != PortalSettings.Current.PortalId)
{
actionResult.AddError(HttpStatusCode.Unauthorized.ToString(), Components.Constants.AuthFailureMessage);
}
if (actionResult.IsSuccess)
{
UpdateSiteAliasRequest PortalAlias = new UpdateSiteAliasRequest()
{
PortalId = alias.PortalID,
PortalAliasID = alias.PortalAliasID,
HTTPAlias = alias.HTTPAlias,
BrowserType = alias.BrowserType.ToString(),
Skin = alias.Skin,
CultureCode = alias.CultureCode,
IsPrimary = alias.IsPrimary
};
actionResult.Data = PortalAlias;
}
}
catch (Exception exc)
{
actionResult.AddError(HttpStatusCode.InternalServerError.ToString(), exc.Message);
}
return(actionResult);
}
private void SetupBasePortalInfo()
{
PortalController pc = new PortalController();
int basePortalId = Convert.ToInt32(Settings["BasePortal"]);
if (basePortalId < 0)
{
basePortalId = 0;
}
BasePortalInfo = pc.GetPortal(basePortalId);
if (!BasePortalInfo.HomeDirectory.EndsWith("/"))
{
BasePortalInfo.HomeDirectory += "/";
}
PortalAliasController pac = new PortalAliasController();
ArrayList aliases = pac.GetPortalAliasArrayByPortalID(basePortalId);
PortalAliasInfo pai = (PortalAliasInfo)aliases[0];
OPTabId = DataProvider.Instance().GetFirstSCAOnlineOPTabId();
BasePortalSettings = new PortalSettings(OPTabId, pai);
BasePortalHttpAddress = Globals.AddHTTP(pai.HTTPAlias);
if (!BasePortalHttpAddress.EndsWith("/"))
{
BasePortalHttpAddress += "/";
}
}
private void InitPortalSettings(ref PortalSettings PS, int tabId, PortalAliasInfo portalAlias)
{
if (PS == null)
{
PS = new PortalSettings(tabId, portalAlias);
}
}
private static string GetFormattedLink(object dataItem)
{
PortalAliasInfo ps = new PortalAliasInfo();
StringBuilder returnValue = new StringBuilder();
if ((dataItem is TabInfo))
{
TabInfo tab = (TabInfo)dataItem;
{
int index = 0;
TabController.Instance.PopulateBreadCrumbs(ref tab);
foreach (TabInfo t in tab.BreadCrumbs)
{
if (index > 0)
{
returnValue.Append(" > ");
}
if ((tab.BreadCrumbs.Count - 1 == index))
{
string url = Globals.AddHTTP(t.PortalID == Null.NullInteger ? ps.HTTPAlias : PortalAliasController.Instance.GetPortalAliasesByPortalId(t.PortalID).ToList().OrderByDescending(a => a.IsPrimary).FirstOrDefault().HTTPAlias) + "/Default.aspx?tabId=" + t.TabID;
returnValue.AppendFormat("<a target=\"_blank\" href=\"{0}\">{1}</a>", url, t.LocalizedTabName);
}
else
{
returnValue.AppendFormat("{0}", t.LocalizedTabName);
}
index = index + 1;
}
}
}
return(returnValue.ToString());
}
public void Services_Controller_AddPortalAlias_WhenAliasExists_AddIsNotInvoked()
{
// arrange
var controllerMock = new Mock <Components.SecurityController>();
var portalAliasControllerMock = new Mock <IPortalAliasController>();
var portalAliasInfo = new PortalAliasInfo
{
HTTPAlias = SomeAlias,
PortalID = PortalId,
};
portalAliasControllerMock
.Setup(c => c.GetPortalAlias(SomeAlias, PortalId))
.Returns(() => portalAliasInfo);
var sut = new SecurityController(controllerMock.Object, portalAliasControllerMock.Object);
// act
sut.AddPortalAlias(SslUrl, PortalId);
// assert
portalAliasControllerMock.Verify(
c =>
c.AddPortalAlias(It.Is <PortalAliasInfo>(match =>
match.HTTPAlias == SomeAlias && match.PortalID == PortalId)), Times.Never);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var tc = new TabController();
var tab = tc.GetTabByName(_aboutUsPageName, PortalId);
_tabId = tab.TabID;
//Add Portal Aliases
var aliasController = new PortalAliasController();
TestUtil.ReadStream(String.Format("{0}", "Aliases"), (line, header) =>
{
string[] fields = line.Split(',');
var alias = aliasController.GetPortalAlias(fields[0], PortalId);
if (alias == null)
{
alias = new PortalAliasInfo
{
HTTPAlias = fields[0],
PortalID = PortalId
};
TestablePortalAliasController.Instance.AddPortalAlias(alias);
}
});
TestUtil.ReadStream(String.Format("{0}", "Users"), (line, header) =>
{
string[] fields = line.Split(',');
TestUtil.AddUser(PortalId, fields[0].Trim(), fields[1].Trim(), fields[2].Trim());
});
}
/// <summary>
/// cmdUpdate_Click runs when the Update button is clicked
/// </summary>
/// <history>
/// [cnurse] 01/17/2005 documented
/// </history>
protected void cmdUpdate_Click(Object sender, EventArgs e)
{
try
{
string strAlias = txtAlias.Text;
if (!String.IsNullOrEmpty(strAlias))
{
if (strAlias.IndexOf("://") != -1)
{
strAlias = strAlias.Remove(0, strAlias.IndexOf("://") + 3);
}
if (strAlias.IndexOf("\\\\") != -1)
{
strAlias = strAlias.Remove(0, strAlias.IndexOf("\\\\") + 2);
}
PortalAliasController p = new PortalAliasController();
if (ViewState["PortalAliasID"] != null)
{
PortalAliasInfo objPortalAliasInfo = new PortalAliasInfo();
objPortalAliasInfo.PortalAliasID = Convert.ToInt32(ViewState["PortalAliasID"]);
objPortalAliasInfo.PortalID = Convert.ToInt32(ViewState["PortalID"]);
objPortalAliasInfo.HTTPAlias = strAlias;
try
{
p.UpdatePortalAliasInfo(objPortalAliasInfo);
}
catch
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("DuplicateAlias", this.LocalResourceFile), ModuleMessageType.RedError);
return;
}
}
else
{
PortalAliasInfo objPortalAliasInfo;
objPortalAliasInfo = p.GetPortalAlias(strAlias, Convert.ToInt32(ViewState["PortalAliasID"]));
if (objPortalAliasInfo == null)
{
objPortalAliasInfo = new PortalAliasInfo();
objPortalAliasInfo.PortalID = Convert.ToInt32(ViewState["PortalID"]);
objPortalAliasInfo.HTTPAlias = strAlias;
p.AddPortalAlias(objPortalAliasInfo);
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("DuplicateAlias", this.LocalResourceFile), ModuleMessageType.RedError);
return;
}
}
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("Success", this.LocalResourceFile), ModuleMessageType.GreenSuccess);
Response.Redirect(Convert.ToString(ViewState["UrlReferrer"]), true);
}
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
/// <summary>
/// Transforms a friendly Url into a querystring. Used as input into the rewriting process, after the Url Rewriting process has identified the correct Hotcakes Commerce Page.
/// </summary>
/// <param name="urlParms">string array of the friendly Url Path elements, separated by /</param>
/// <param name="tabId">TabId of page the Friendly Url </param>
/// <param name="portalId">PortalId of the Friendly Url</param>
/// <remarks>This method will be only called if there is no match between the Page Index entries this Provider supplies via the 'CreatePageIndex' method. This method is called
/// when a Hotcakes Commerce page match is found in the requested path, and there are other parameters behind the page path. You should only return a TabId in the querystring, when the ChangeFriendlyUrl function is returning 'true' for the output value of 'useDnnPagePath'.</remarks>
/// <example>
/// Given a Url of example.com/pagename/key/value - this method will be called with key,value in the urlParms array with a page match on 'pagename'. The method should return 'key=value'.
/// Or, if given a Url of example.com/pagename/my-friendly-module-url, it should transform 'my-friendly-module-url' into whatever the module actually uses to build content. This might mean returning 'article=2354' derived from doing a specific lookup on 'my-friendly-module-url'.
/// Warning: It's unwise to do a specific database lookup for each call of this method. This method needs to be high-performance so should use a stateless method (ie, regex parse) or, if looking up database values, cached hashtables or thread-safe dictionaries.
/// </example>
/// <returns>Querystring value in key=value format, which will be used as an input to the rewriting function.</returns>
public abstract string TransformFriendlyUrlToQueryString(string[] urlParms,
int tabId, int portalId,
FriendlyUrlOptions options,
string cultureCode,
PortalAliasInfo portalAlias,
ref List <string> messages,
out int status,
out string location);
private PortalAliasInfo CreatePortalAlias(int portalId)
{
var portalAlias = new PortalAliasInfo()
{
PortalID = portalId,
};
return(portalAlias);
}
///<summary>
/// Set the portalid, taking the current request and locating which portal is being called based on this request.
/// </summary>
/// <param name="request">request</param>
private void SetPortalId(HttpRequest request)
{
string domainName = DotNetNuke.Common.Globals.GetDomainName(request, true);
string portalAlias = domainName.Substring(0, domainName.IndexOf("/svc"));
PortalAliasInfo pai = PortalSettings.GetPortalAliasInfo(portalAlias);
if (pai != null)
{
PortalId = pai.PortalID;
}
}
public override void SetUp()
{
base.SetUp();
UpdateTabName(_tabId, "About Us");
CacheController.FlushPageIndexFromCache();
GetDefaultAlias();
_redirectMode = PortalController.GetPortalSetting("PortalAliasMapping", PortalId, "CANONICALURL");
_primaryAlias = null;
_customLocale = null;
}
public static void AddPortalAlias(PortalAliasInfo portal)
{
DatabaseHelper.ExecuteStoredProcedure("AddPortalAlias",
portal.PortalID,
portal.HTTPAlias,
portal.CultureCode,
portal.Skin,
portal.BrowserType,
portal.IsPrimary,
-1);
}
public void DeletePortalAlias(PortalAliasInfo portalAlias)
{
//Delete Alias
DataProvider.Instance().DeletePortalAlias(portalAlias.PortalAliasID);
//Log Event
LogEvent(portalAlias, EventLogController.EventLogType.PORTALALIAS_DELETED);
//clear portal alias cache
ClearCache(false);
}
///<summary>
/// Set the portalid, taking the current request and locating which portal is being called based on this request.
/// </summary>
/// <param name="request">request</param>
private static void SetPortalId(HttpRequest request)
{
string domainName = Globals.GetDomainName(request, true);
PortalAliasInfo pai = PortalSettings.GetPortalAliasInfo(domainName);
if (pai != null)
{
PortalId = pai.PortalID;
}
}
public static string GetPermalink(this INewsEntry newsEntry,
PermalinkMode permalinkMode,
ModuleController moduleController,
PortalAliasInfo portalAlias,
int moduleId,
int tabId)
{
return((permalinkMode == PermalinkMode.Friendly) ?
GetPermalinkFriendly(newsEntry, moduleController, moduleId, tabId) :
GetPermalinkRaw(newsEntry, moduleController, portalAlias, moduleId, tabId));
}
public void AdvancedUrlRewriter_PrimaryPortalAlias(Dictionary <string, string> testFields)
{
string defaultAlias = testFields["DefaultAlias"];
var settings = UrlTestFactoryClass.GetSettings("UrlRewrite", testFields["TestName"]);
settings.PortalId = PortalId;
string language = testFields["Language"].Trim();
string skin = testFields["Skin"].Trim();
if (!String.IsNullOrEmpty(language))
{
_customLocale = new Locale {
Code = language, Fallback = "en-US"
};
_customLocale.Text = CultureInfo.CreateSpecificCulture(_customLocale.Code).NativeName;
Localization.SaveLanguage(_customLocale);
Localization.AddLanguageToPortals(_customLocale.LanguageId);
}
if (testFields.ContainsKey("Final Url"))
{
testFields["Final Url"] = testFields["Final Url"].Replace("{useAlias}", defaultAlias);
}
PortalController.UpdatePortalSetting(PortalId, "PortalAliasMapping", "REDIRECT");
var alias = PortalAliasController.Instance.GetPortalAlias(defaultAlias, PortalId);
if (alias == null)
{
alias = new PortalAliasInfo
{
HTTPAlias = defaultAlias,
PortalID = PortalId,
IsPrimary = true
};
if (!(String.IsNullOrEmpty(language) && String.IsNullOrEmpty(skin)))
{
alias.CultureCode = language;
alias.Skin = skin;
}
PortalAliasController.Instance.AddPortalAlias(alias);
}
SetDefaultAlias(defaultAlias);
ExecuteTest(settings, testFields, false);
alias = PortalAliasController.Instance.GetPortalAlias(defaultAlias, PortalId);
if (alias != null)
{
PortalAliasController.Instance.DeletePortalAlias(alias);
}
}
public ActionResult AddSiteAlias(UpdateSiteAliasRequest request)
{
ActionResult actionResult = new ActionResult();
try
{
int pid = request.PortalId ?? PortalSettings.Current.PortalId;
if (!UserInfo.IsSuperUser && pid != PortalSettings.Current.PortalId)
{
actionResult.AddError(HttpStatusCode.Unauthorized.ToString(), Components.Constants.AuthFailureMessage);
}
string strAlias = request.HTTPAlias;
if (!string.IsNullOrEmpty(strAlias))
{
strAlias = strAlias.Trim();
}
if (IsHttpAliasValid(strAlias))
{
PortalAliasCollection aliases = PortalAliasController.Instance.GetPortalAliases();
if (aliases.Contains(strAlias))
{
actionResult.AddError(HttpStatusCode.BadRequest.ToString(), string.Format(Localization.GetString("DuplicateAlias", Dnn.PersonaBar.SiteSettings.Components.Constants.Constants.LocalResourcesFile)));
}
if (actionResult.IsSuccess)
{
Enum.TryParse(request.BrowserType, out BrowserTypes browser);
PortalAliasInfo portalAlias = new PortalAliasInfo()
{
PortalID = pid,
HTTPAlias = strAlias,
Skin = request.Skin,
CultureCode = request.CultureCode,
BrowserType = browser,
IsPrimary = request.IsPrimary
};
PortalAliasController.Instance.AddPortalAlias(portalAlias);
actionResult.Data = new { SiteAliases = Managers.DomainManager.GetSiteAliases(PortalSettings.Current.PortalId, UserInfo).Data };
}
}
else
{
actionResult.AddError(HttpStatusCode.BadRequest.ToString(), string.Format(Localization.GetString("InvalidAlias", Dnn.PersonaBar.SiteSettings.Components.Constants.Constants.LocalResourcesFile)));
}
}
catch (Exception exc)
{
actionResult.AddError(HttpStatusCode.InternalServerError.ToString(), exc.Message);
}
return(actionResult);
}
public void AdvancedUrlRewriter_0_PrimaryPortalAlias(Dictionary <string, string> testFields)
{
var defaultAlias = testFields["DefaultAlias"];
var settings = UrlTestFactoryClass.GetSettings("UrlRewrite", testFields["TestName"], this.PortalId);
var language = testFields["Language"].Trim();
var skin = testFields["Skin"].Trim();
if (!string.IsNullOrEmpty(language))
{
this.customLocale = new Locale {
Code = language, Fallback = "en-US"
};
this.customLocale.Text = CultureInfo.GetCultureInfo(this.customLocale.Code).NativeName;
Localization.SaveLanguage(this.customLocale);
Localization.AddLanguageToPortals(this.customLocale.LanguageId);
}
if (testFields.ContainsKey("Final Url"))
{
testFields["Final Url"] = testFields["Final Url"].Replace("{useAlias}", defaultAlias);
}
PortalController.UpdatePortalSetting(this.PortalId, "PortalAliasMapping", "REDIRECT", true, "en-us");
var portalAliasService = Globals.DependencyProvider.GetRequiredService <IPortalAliasService>();
var alias = portalAliasService.GetPortalAlias(defaultAlias, this.PortalId);
if (alias == null)
{
alias = new PortalAliasInfo();
alias.HttpAlias = defaultAlias;
alias.PortalId = this.PortalId;
alias.IsPrimary = true;
if (!(string.IsNullOrEmpty(language) && string.IsNullOrEmpty(skin)))
{
alias.CultureCode = language;
alias.Skin = skin;
}
portalAliasService.AddPortalAlias(alias);
}
this.SetDefaultAlias(defaultAlias);
this.ExecuteTest(settings, testFields, false);
alias = portalAliasService.GetPortalAlias(defaultAlias, this.PortalId);
if (alias != null)
{
portalAliasService.DeletePortalAlias(alias);
}
}
public override void DoWork()
{
try
{
// perform some task
List <DNNSnapshotInfo> items;
DNNSnapshotController controller = new DNNSnapshotController();
//string vText = HttpContext.Current.Request.Url.Host.ToString();
items = controller.GetDNNSnapshotModules();
// items[0].ToString();
string myList = "";
string myMessage = "";
string vPortalAlias = "";
for (int i = 0; i <= items.Count - 1; i++)
{
PortalAliasController paController = new PortalAliasController();
PortalAliasCollection aliasCollection = paController.GetPortalAliasByPortalID(items[i].PortalID);
IDictionaryEnumerator hs = aliasCollection.GetEnumerator();
hs.MoveNext();
PortalAliasInfo paInfo = (PortalAliasInfo)hs.Entry.Value;
vPortalAlias = paInfo.HTTPAlias;
if (CheckPage("http://" + vPortalAlias + "/Default.aspx?TabID=" + items[i].TabID.ToString() + "&ScheduledTask=true", out myMessage) == true)
{
myList += "Status " + myMessage + " - Tab " + items[i].TabID.ToString() + " Loaded!<br>";
}
else
{
myList += myMessage + " - ERROR!!!<br>";
}
}
// report success to the scheduler framework
ScheduleHistoryItem.Succeeded = true;
this.ScheduleHistoryItem.AddLogNote("Processing completed at " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString() + "<br>" + myList.ToString());
}
catch (Exception exc)
{
ScheduleHistoryItem.Succeeded = false;
ScheduleHistoryItem.AddLogNote("EXCEPTION: " + exc.ToString());
Errored(ref exc);
Exceptions.LogException(exc);
}
}
///<summary>
/// Locate Portal takes the current request and locates which portal is being called based on this request.
/// </summary>
/// <param name="request">request</param>
private void LocatePortal(HttpRequest request)
{
string domainName = Globals.GetDomainName(request, true);
string portalAlias = domainName;
PortalAliasInfo pai = PortalAliasController.GetPortalAliasInfo(portalAlias);
if (pai != null)
{
PortalId = pai.PortalID;
PortalSettings ps = Utility.GetPortalSettings(pai.PortalID);
PortalPath = ps.HomeDirectory;
}
}
public static string Impersonate(HttpContext context, PortalSettings pS, int cUserId, int iUserId, bool RememberOriginalUser)
{
try
{
PortalAliasInfo p = new PortalAliasInfo();
UserInfo iUserInfo = UserController.GetUserById(pS.PortalId, iUserId);
if (iUserInfo.IsInRole("Administrators") && !pS.UserInfo.IsSuperUser)
{
return("Cannot impersonate an Administrator!");
}
if (iUserInfo != null)
{
if (context.Session != null)
{
if (RememberOriginalUser)
{
if (context.Session["LA-RevertId"] == null)
{
context.Session.Add("LA-RevertId", cUserId);
}
if (context.Session["LA-RevertTabId"] == null)
{
context.Session.Add("LA-RevertTabId", pS.ActiveTab.TabID);
}
}
else
{
context.Session.Remove("LA-RevertId");
context.Session.Remove("LA-RevertTabId");
}
}
DotNetNuke.Common.Utilities.DataCache.ClearUserCache(pS.PortalId, context.User.Identity.Name);
new PortalSecurity().SignOut();
UserController.UserLogin(pS.PortalId, iUserInfo, pS.PortalName, context.Request.UserHostAddress, false);
return("Success");
}
}
catch (Exception ex)
{
Exceptions.LogException(ex);
}
return("An error occurred impersonating the user. Please refer to event viewer for details!");
}
public string GetRouteName(string moduleFolderName, string routeName, PortalAliasInfo portalAlias)
{
var alias = portalAlias.HTTPAlias;
string appPath = TestableGlobals.Instance.ApplicationPath;
if (!string.IsNullOrEmpty(appPath))
{
int i = alias.IndexOf(appPath, StringComparison.OrdinalIgnoreCase);
if (i > 0)
{
alias = alias.Remove(i, appPath.Length);
}
}
return(GetRouteName(moduleFolderName, routeName, CalcAliasPrefixCount(alias)));
}
/// -----------------------------------------------------------------------------
/// <summary>
/// AddAlias runs when the Add button is clicked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 12/12/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
private void AddAlias(object sender, EventArgs e)
{
//Add a new empty rule and set the editrow to the new row
var portalAlias = new PortalAliasInfo();
portalAlias.PortalID = intPortalId;
Aliases.Add(portalAlias);
dgPortalAlias.EditItemIndex = Aliases.Count - 1;
//Set the AddMode to true
AddMode = true;
//Rebind the collection
BindAliases();
}
protected static void AutoAddAlias(HttpContext context)
{
var portalId = Host.Host.HostPortalID;
//the domain name was not found so try using the host portal's first alias
if (portalId > Null.NullInteger)
{
var portalAliasInfo = new PortalAliasInfo {
PortalID = portalId, HTTPAlias = Globals.GetDomainName(context.Request, true)
};
PortalAliasController.Instance.AddPortalAlias(portalAliasInfo);
context.Response.Redirect(context.Request.Url.ToString(), true);
}
}
public static string GetPermalinkRaw(this INewsEntry newsEntry,
ModuleController moduleController,
PortalAliasInfo portalAlias,
int moduleId,
int tabId)
{
var agentModule = GetAgentModuleOnce(moduleController, newsEntry);
if (agentModule != null)
{
return(Globals.AddHTTP(portalAlias.HTTPAlias + "/default.aspx?tabid=" + agentModule.TabID));
}
return(Globals.AddHTTP(portalAlias.HTTPAlias + "/default.aspx?tabid=" + tabId
+ "&mid=" + moduleId + "&ctl=entry&entryid=" + newsEntry.EntryId));
}
protected void AddAlias(object sender, EventArgs e)
{
//Add a new empty rule and set the editrow to the new row
var portalAlias = new PortalAliasInfo {
PortalID = CurrentPortalId
};
Aliases.Add(portalAlias);
Grid.EditItemIndex = Aliases.Count - 1;
//Set the AddMode to true
AddMode = true;
//Rebind the collection
BindAliases();
}
private string GetPortalAlias(int PortalId)
{
PortalAliasController paController = new PortalAliasController();
PortalAliasCollection paCollection = paController.GetPortalAliasByPortalID(PortalId);
foreach (DictionaryEntry pa in paCollection)
{
PortalAliasInfo paI = (PortalAliasInfo)pa.Value;
return(paI.HTTPAlias);
}
return("PortalAlias not found");
}
protected string GetPortalAlias(int portalAliasId)
{
StringBuilder sb = new StringBuilder();
if (portalAliasId >= 0)
{
DotNetNuke.Entities.Portals.PortalAliasController pac = new PortalAliasController();
PortalAliasInfo pa = pac.GetPortalAliasByPortalAliasID(portalAliasId);
if (pa != null)
{
sb.Append(pa.HTTPAlias);
}
}
return(sb.ToString());
}
public int AddPortalAlias(PortalAliasInfo portalAlias)
{
//Add Alias
int Id = _dataProvider.AddPortalAlias(portalAlias.PortalID,
portalAlias.HTTPAlias.ToLower().Trim('/'),
portalAlias.CultureCode,
portalAlias.Skin,
portalAlias.BrowserType.ToString(),
portalAlias.IsPrimary,
UserController.GetCurrentUserInfo().UserID);
//Log Event
LogEvent(portalAlias, EventLogController.EventLogType.PORTALALIAS_CREATED);
//clear portal alias cache
ClearCache(true);
return Id;
}
public void UpdatePortalAlias(PortalAliasInfo portalAlias)
{
//Update Alias
DataProvider.Instance().UpdatePortalAliasInfo(portalAlias.PortalAliasID,
portalAlias.PortalID,
portalAlias.HTTPAlias.ToLower().Trim('/'),
portalAlias.CultureCode,
portalAlias.Skin,
portalAlias.BrowserType.ToString(),
portalAlias.IsPrimary,
UserController.GetCurrentUserInfo().UserID);
//Log Event
LogEvent(portalAlias, EventLogController.EventLogType.PORTALALIAS_UPDATED);
//clear portal alias cache
ClearCache(false);
}
private static void LogEvent(PortalAliasInfo portalAlias, EventLogController.EventLogType logType)
{
int userId = UserController.GetCurrentUserInfo().UserID;
var eventLogController = new EventLogController();
eventLogController.AddLog(portalAlias, PortalController.GetCurrentPortalSettings(), userId, "", logType);
}
public void DeletePortalAlias(PortalAliasInfo portalAlias)
{
//Delete Alias
DataProvider.Instance().DeletePortalAlias(portalAlias.PortalAliasID);
//Log Event
LogEvent(portalAlias, EventLogController.EventLogType.PORTALALIAS_DELETED);
//clear portal alias cache
ClearCache(false);
}
