//====================================================================================================
/// <summary>
/// load a feature from the current row of a contentSet
/// </summary>
/// <param name="CP"></param>
/// <param name="csFeature"></param>
/// <returns></returns>
public static PortalDataFeatureModel loadPortalFeatureFromCs(CPBaseClass CP, CPCSBaseClass csFeature)
{
PortalDataFeatureModel feature = new PortalDataFeatureModel();
try {
feature.id = csFeature.GetInteger("id");
feature.name = csFeature.GetText("name");
feature.heading = csFeature.GetText("heading");
feature.sortOrder = csFeature.GetText("sortOrder");
feature.addPadding = csFeature.GetBoolean("addPadding");
if (string.IsNullOrEmpty(feature.heading))
{
feature.heading = feature.name;
}
feature.guid = csFeature.GetText("ccguid");
if (string.IsNullOrEmpty(feature.guid))
{
feature.guid = CP.Utils.CreateGuid();
csFeature.SetField("ccguid", feature.guid);
}
//
feature.addonId = csFeature.GetInteger("addonId");
feature.dataContentId = csFeature.GetInteger("dataContentId");
feature.parentFeatureId = csFeature.GetInteger("parentFeatureId");
} catch (Exception ex) {
CP.Site.ErrorReport(ex, "exception in loadPortal");
throw;
}
return(feature);
}
//====================================================================================================
/// <summary>
/// create a feature list box
/// </summary>
/// <param name="cp"></param>
/// <param name="feature"></param>
/// <returns></returns>
public static string getFeatureList(CPBaseClass cp, PortalDataModel portalData, PortalDataFeatureModel feature, string frameRqs)
{
try {
//string activeNavHeading = feature.heading;
string items = "";
foreach (KeyValuePair <string, PortalDataFeatureModel> kvp in portalData.featureList)
{
PortalDataFeatureModel liFeature = kvp.Value;
if ((liFeature.parentFeatureId == feature.id) && (liFeature.parentFeatureId != 0))
{
string featureHeading = liFeature.heading;
if (string.IsNullOrEmpty(featureHeading))
{
featureHeading = liFeature.name;
}
if (liFeature.dataContentId != 0)
{
//
// -- display content button if content is not developeronly, or if this is a developer
ContentModel featureContent = DbBaseModel.create <ContentModel>(cp, liFeature.dataContentId);
if (featureContent != null)
{
if ((!featureContent.developerOnly) || (cp.User.IsDeveloper))
{
string qs = frameRqs;
qs = cp.Utils.ModifyQueryString(qs, "addonid", "", false);
qs = cp.Utils.ModifyQueryString(qs, Constants.rnDstFeatureGuid, "", false);
qs = cp.Utils.ModifyQueryString(qs, "cid", liFeature.dataContentId.ToString());
items += "<li><a target=\"_blank\" href=\"?" + qs + "\">" + featureHeading + "</a></li>";
}
}
}
else
{
string qs = cp.Utils.ModifyQueryString(frameRqs, Constants.rnDstFeatureGuid, liFeature.guid);
items += "<li><a href=\"?" + qs + "\">" + featureHeading + "</a></li>";
}
}
}
FormSimpleClass content = new FormSimpleClass {
title = feature.heading,
body = "<ul class=\"afwButtonList\">" + items + "</ul>"
};
return(content.getHtml(cp));
} catch (Exception ex) {
cp.Site.ErrorReport(ex, "portalClass.getFeatureList exception");
throw;
}
}
//====================================================================================================
/// <summary>
/// get the portal html. portalId=0 returns the first order by id.
/// </summary>
/// <param name="CP"></param>
/// <param name="portalSelectSqlCriteria"></param>
/// <returns></returns>
public string getPortalAddonHtml(CPBaseClass CP, int portalId)
{
try {
if (!CP.User.IsAdmin)
{
return(Constants.blockedMessage);
}
PortalDataModel portalData = PortalDataModel.create(CP, portalId);
//string frameRqs = CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnSetPortalId, portalData.id.ToString(), true);
//
// -- Add Nav items
PortalBuilderClass portalBuilder = new PortalBuilderClass();
foreach (KeyValuePair <string, PortalDataFeatureModel> kvp in portalData.featureList)
{
PortalDataFeatureModel feature = kvp.Value;
if (feature.parentFeatureId == 0)
{
//
// -- feature has no parent, add to nav
var navFlyoutList = new List <PortalBuilderSubNavItemViewModel>();
if (feature.addonId == 0 && feature.dataContentId == 0)
{
//
// -- parent feature has no addon or content, add flyout if it has child features
foreach (var subFeature in feature.subFeatureList)
{
navFlyoutList.Add(new PortalBuilderSubNavItemViewModel {
subActive = true,
subCaption = subFeature.heading,
subIsPortalLink = false,
subLink = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, subFeature.guid),
sublinkTarget = (subFeature.dataContentId > 0) || (!string.IsNullOrEmpty(subFeature.dataContentGuid)) ? "_blank" : ""
});
}
}
portalBuilder.addNav(new PortalBuilderNavItemViewModel {
active = false,
caption = feature.heading,
isPortalLink = false,
link = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, feature.guid),
linkTarget = (feature.dataContentId > 0) || (!string.IsNullOrEmpty(feature.dataContentGuid)) ? "_blank" : "",
navFlyoutList = navFlyoutList
});
portalBuilder.navCaption = feature.heading;
portalBuilder.navLink = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, feature.guid);
}
}
//
// add developer nav item
//
if (CP.User.IsDeveloper)
{
if (portalData.featureList.ContainsKey(Constants.devToolGuid))
{
CP.Site.ErrorReport("loadPortalFromDb, the portal [" + portalData.name + "] appears to have the devTool feature saved in either the Db features or the defaultConfig. This is not allowed.");
}
else
{
portalBuilder.addNav();
portalBuilder.navCaption = "Developer Tool";
portalBuilder.navLink = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, Constants.devToolGuid);
}
}
//
// add linked features nav items
//
if (portalData.linkedPortals.Count > 0)
{
foreach (PortalDataModel linkedPortal in portalData.linkedPortals)
{
portalBuilder.addNav();
portalBuilder.navCaption = linkedPortal.name;
portalBuilder.navLink = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnSetPortalId, linkedPortal.id.ToString());
}
}
string body = "";
string dstFeatureGuid = CP.Doc.GetText(Constants.rnDstFeatureGuid);
string activeNavHeading = "";
//
// execute feature, if it returns empty, display default feature
//
if (dstFeatureGuid == Constants.devToolGuid)
{
//
// execute developer tool panel
//
CP.Doc.AddRefreshQueryString(Constants.rnDstFeatureGuid, Constants.devToolGuid);
body = DevToolView.getDevTool(CP, portalData, CP.Doc.RefreshQueryString);
activeNavHeading = "Developer Tool";
}
else
{
if (portalData.featureList.ContainsKey(dstFeatureGuid))
{
//
// add feature guid to frameRqs so if the feature uses ajax, the featureGuid will be part of it
// add feature guid to rqs so if an addon is used that does not support frameRqs it will work
//
PortalDataFeatureModel dstDataFeature = portalData.featureList[dstFeatureGuid];
//frameRqs = CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, feature.guid);
if (dstDataFeature.addonId != 0)
{
//
// feature is an addon, execute it
//
CP.Doc.SetProperty(Constants.rnFrameRqs, CP.Doc.RefreshQueryString);
CP.Doc.AddRefreshQueryString(Constants.rnDstFeatureGuid, dstDataFeature.guid);
body = CP.Addon.Execute(dstDataFeature.addonId);
//
// -- portal title is a doc property set in each portal-builder that populates the title in the subnav.
portalBuilder.subNavTitle = CP.Doc.GetText("portalSubNavTitle");
//
// -- if the feature addon has sibling features, build the subnav
//
if (!string.IsNullOrEmpty(dstDataFeature.parentFeatureGuid))
{
if (portalData.featureList.ContainsKey(dstDataFeature.parentFeatureGuid))
{
PortalDataFeatureModel dstFeatureParent = portalData.featureList[dstDataFeature.parentFeatureGuid];
if (dstFeatureParent != null)
{
if (dstFeatureParent.addonId > 0 || dstFeatureParent.dataContentId > 0)
{
//
// -- if parent is content or addon features, show subnav (otherwise, show flyout)
foreach (var dstFeatureSibling in dstFeatureParent.subFeatureList)
{
portalBuilder.addSubNav(new PortalBuilderSubNavItemViewModel {
subActive = true,
subCaption = dstFeatureSibling.heading,
subIsPortalLink = false,
subLink = "?" + CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, dstFeatureSibling.guid),
sublinkTarget = (dstFeatureSibling.dataContentId > 0) || (!string.IsNullOrEmpty(dstFeatureSibling.dataContentGuid)) ? "_blank" : ""
});
}
}
}
}
}
//
//
}
else if (dstDataFeature.dataContentId != 0)
{
//
// this is a data content feature -- should not be here, link should have taken them to the content
//
CP.Response.Redirect("?cid=" + dstDataFeature.dataContentId.ToString());
FormSimpleClass content = new FormSimpleClass {
title = dstDataFeature.heading,
body = "Redirecting to content"
};
body = content.getHtml(CP);
}
else
{
//
// this is a feature list, display the feature list
//
body = FeatureListView.getFeatureList(CP, portalData, dstDataFeature, CP.Doc.RefreshQueryString);
}
//
// -- set active heading
PortalDataFeatureModel dstFeatureRootFeature = PortalDataFeatureModel.getRootFeature(CP, dstDataFeature, portalData.featureList);
activeNavHeading = dstFeatureRootFeature.heading;
//
// -- if body not created, consider this a feature list
if (string.IsNullOrEmpty(body))
{
foreach (KeyValuePair <string, PortalDataFeatureModel> kvp in portalData.featureList)
{
PortalDataFeatureModel parentFeature = kvp.Value;
if (parentFeature.id == dstDataFeature.parentFeatureId)
{
//
// if feature returned empty and it is in a feature list, execute the feature list
body = FeatureListView.getFeatureList(CP, portalData, parentFeature, CP.Doc.RefreshQueryString);
}
}
}
//
// -- add pading
if (dstDataFeature.addPadding)
{
body = CP.Html.div(body, "", "afwBodyPad", "");
}
}
}
if (string.IsNullOrEmpty(body))
{
//
// if the feature returns blank, run the default feature
//
if (portalData.defaultFeature != null)
{
PortalDataFeatureModel feature = portalData.defaultFeature;
activeNavHeading = feature.heading;
//frameRqs = CP.Utils.ModifyQueryString(CP.Doc.RefreshQueryString, Constants.rnDstFeatureGuid, feature.guid);
CP.Doc.SetProperty(Constants.rnFrameRqs, CP.Doc.RefreshQueryString);
CP.Doc.AddRefreshQueryString(Constants.rnDstFeatureGuid, feature.guid);
body = CP.Addon.Execute(feature.addonId);
if (feature.addPadding)
{
body = CP.Html.div(body, "", "afwBodyPad", "");
}
}
if (string.IsNullOrEmpty(body))
{
FormSimpleClass simple = new FormSimpleClass {
body = "This portal feature has no content."
};
body = simple.getHtml(CP);
}
}
portalBuilder.setActiveNav(activeNavHeading);
//
//Assemble
//
portalBuilder.body = CP.Html.div(body, "", "", "afwBodyFrame");
portalBuilder.title = portalData.name;
portalBuilder.isOuterContainer = true;
string returnHtml = portalBuilder.getHtml(CP);
//
// assemble body
//
CP.Doc.AddHeadStyle(Properties.Resources.styles);
CP.Doc.AddHeadJavascript("var afwFrameRqs='" + CP.Doc.RefreshQueryString + "';");
CP.Doc.AddHeadJavascript(Properties.Resources.javascript);
//
return(returnHtml);
} catch (Exception ex) {
CP.Site.ErrorReport(ex, "portalClass");
throw;
}
}
//====================================================================================================
/// <summary>
/// If the portal does not exist in the Db, create it and all its features based on the portal argument
/// </summary>
/// <param name="CP"></param>
/// <param name="newPortal"></param>
public static void savePortalToDb(CPBaseClass CP, PortalDataModel newPortal)
{
try {
CPCSBaseClass cs = CP.CSNew();
CPCSBaseClass cs2 = CP.CSNew();
//
// insert or update the portal record
//
if (!cs.Open("portals", "ccguid=" + CP.Db.EncodeSQLText(newPortal.guid), "", true, "", 9999, 1))
{
cs.Close();
cs.Insert("portals");
newPortal.id = cs.GetInteger("id");
}
newPortal.id = cs.GetInteger("id");
cs.SetField("ccguid", newPortal.guid);
cs.SetField("name", newPortal.name);
cs.Close();
//
// insert or update portal feature records
//
foreach (KeyValuePair <string, PortalDataFeatureModel> kvp in newPortal.featureList)
{
PortalDataFeatureModel feature = kvp.Value;
if (feature.guid != Constants.devToolGuid)
{
if (!cs.Open("portal features", "ccguid=" + CP.Db.EncodeSQLText(feature.guid), "", true, "", 9999, 1))
{
cs.Insert("portal features");
cs.SetField("ccGuid", feature.guid);
}
if (cs.OK())
{
feature.id = cs.GetInteger("id");
cs.SetField("portalId", newPortal.id.ToString());
cs.SetField("name", feature.name);
cs.SetField("heading", feature.heading);
cs.SetField("sortOrder", feature.sortOrder);
if (feature.addonId == 0 && !string.IsNullOrEmpty(feature.addonGuid))
{
//
// lookup addon by guid, set addonid
//
if (cs2.Open("add-ons", "ccguid=" + CP.Db.EncodeSQLText(feature.addonGuid), "", true, "", 9999, 1))
{
cs.SetField("addonId", cs2.GetInteger("id").ToString());
}
cs2.Close();
}
if (feature.dataContentId == 0 && !string.IsNullOrEmpty(feature.dataContentGuid))
{
//
// save dataContentId based on dataContentGuid
//
if (cs2.Open("content", "ccguid=" + CP.Db.EncodeSQLText(feature.dataContentGuid), "", true, "", 9999, 1))
{
feature.dataContentId = cs2.GetInteger("id");
cs.SetField("dataContentId", feature.dataContentId.ToString());
}
cs2.Close();
}
if (newPortal.defaultFeature.guid == feature.guid)
{
newPortal.defaultFeature = feature;
}
}
cs.Close();
}
}
//
// lookup parent features by guid and set id
//
foreach (KeyValuePair <string, PortalDataFeatureModel> kvp in newPortal.featureList)
{
PortalDataFeatureModel feature = kvp.Value;
if (feature.guid != Constants.devToolGuid)
{
if (feature.parentFeatureId == 0 && !string.IsNullOrEmpty(feature.parentFeatureGuid))
{
//
// get the id of the parentFeature
//
if (cs.Open("portal features", "ccguid=" + CP.Db.EncodeSQLText(feature.parentFeatureGuid), "", true, "", 9999, 1))
{
feature.parentFeatureId = cs.GetInteger("id");
}
cs.Close();
if (feature.parentFeatureId > 0)
{
//
// set the parentFeatureId field of the current feature
//
if (cs.Open("portal features", "id=" + feature.id.ToString(), "", true, "", 9999, 1))
{
cs.SetField("parentFeatureId", feature.parentFeatureId.ToString());
}
cs.Close();
}
}
}
}
} catch (Exception ex) {
CP.Site.ErrorReport(ex, "exception in loadPortal");
throw;
}
}
//====================================================================================================
/// <summary>
/// Return a portal object read from the Db based on the portal guid argument
/// </summary>
/// <param name="cp"></param>
/// <param name="portalRecordGuid"></param>
/// <returns></returns>
public static PortalDataModel create(CPBaseClass CP, int portalId)
{
try {
PortalDataModel result = new PortalDataModel {
featureList = new Dictionary <string, PortalDataFeatureModel>()
};
using (CPCSBaseClass portalCs = CP.CSNew()) {
string defaultConfigJson;
if (!portalCs.Open("portals", (portalId == 0 ? "" : "id=" + portalId), "id", true, "", 9999, 1))
{
//
// -- no portals found, create demo portal
portalCs.Close();
result.name = "Empty";
result.guid = "";
result.id = 0;
result.featureList = new Dictionary <string, PortalDataFeatureModel>();
PortalDataFeatureModel feature = new PortalDataFeatureModel {
addonId = 0,
dataContentId = 0,
guid = "",
heading = "Sample",
id = 0,
name = "Demo",
parentFeatureId = 0,
sortOrder = ""
};
return(result);
}
//
// -- load selected portal
result.name = portalCs.GetText("name");
result.guid = portalCs.GetText("ccguid");
result.id = portalCs.GetInteger("id");
int portalDefaultFeatureId = portalCs.GetInteger("defaultFeatureId");
defaultConfigJson = portalCs.GetText("defaultConfigJson");
portalCs.Close();
//
// -- portal links
result.linkedPortals = new List <PortalDataModel>();
string sql = "select p.id,p.ccguid,p.name from ccPortals p left join ccPortalLinks l on l.toPortalId=p.id where p.active>0 and l.fromPortalId=" + result.id;
if (portalCs.OpenSQL(sql))
{
do
{
int linkedPortalId = portalCs.GetInteger("id");
if (!result.id.Equals(linkedPortalId))
{
PortalDataModel linkedPortal = new PortalDataModel {
id = linkedPortalId,
name = portalCs.GetText("name")
};
result.linkedPortals.Add(linkedPortal);
}
portalCs.GoNext();
} while (portalCs.OK());
}
portalCs.Close();
//
// -- load features and subfeatures
string featureSql = ""
+ " select"
+ " f.id,f.name,f.heading,f.sortOrder,f.addPadding,f.ccguid,f.addonId,f.dataContentId,f.parentFeatureId,"
+ " sub.id as subId,sub.name as subName,sub.heading as subheading,sub.sortOrder as subSortOrder,sub.addPadding as subAddPadding,sub.ccguid as subccGuid,sub.addonId as subAddonId,sub.dataContentId as subdatacontentid,sub.parentFeatureId as subparentFeatureId"
+ " from ccPortalFeatures f left join ccPortalFeatures sub on sub.parentFeatureId=f.id "
+ " where (f.active>0) and ((sub.active is null)or(sub.active>0))and f.portalid=" + portalId
+ " order by f.sortOrder,f.name,sub.name";
using (CPCSBaseClass csFeature = CP.CSNew()) {
if (csFeature.OpenSQL(featureSql))
{
//
// -- load features from Db
int lastFeatureId = 0;
PortalDataFeatureModel feature = null;
do
{
if (lastFeatureId != csFeature.GetInteger("id"))
{
//
// -- new feature, load the feature
feature = new PortalDataFeatureModel {
id = csFeature.GetInteger("id"),
name = csFeature.GetText("name"),
heading = (string.IsNullOrEmpty(csFeature.GetText("heading")) ? csFeature.GetText("name") : csFeature.GetText("heading")),
sortOrder = csFeature.GetText("sortOrder"),
addPadding = csFeature.GetBoolean("addPadding"),
guid = csFeature.GetText("ccguid"),
addonId = csFeature.GetInteger("addonId"),
dataContentId = csFeature.GetInteger("dataContentId"),
parentFeatureId = csFeature.GetInteger("parentFeatureId"),
subFeatureList = new List <PortalDataFeatureModel>(),
addonGuid = "",
dataContentGuid = "",
parentFeatureGuid = ""
};
//
// -- add the new feature to the list
string featureGuid = csFeature.GetText("ccguid");
if (result.featureList.ContainsKey(featureGuid))
{
//
// -- data error, duplicate features
CP.Site.ErrorReport("Portal Error, 2 portal features with the same guid [" + featureGuid + "]");
}
else
{
result.featureList.Add(featureGuid, feature);
if (result.defaultFeature == null)
{
result.defaultFeature = feature;
}
if (portalDefaultFeatureId == feature.id)
{
result.defaultFeature = feature;
}
}
}
//
// -- load subfeatures
int subFeatureId = csFeature.GetInteger("subid");
if (subFeatureId > 0)
{
PortalDataFeatureModel subFeature = new PortalDataFeatureModel {
id = subFeatureId,
name = csFeature.GetText("subname"),
heading = (string.IsNullOrEmpty(csFeature.GetText("subheading")) ? csFeature.GetText("subname") : csFeature.GetText("subheading")),
sortOrder = csFeature.GetText("subsortOrder"),
addPadding = csFeature.GetBoolean("subaddPadding"),
guid = csFeature.GetText("subccguid"),
addonId = csFeature.GetInteger("subaddonId"),
dataContentId = csFeature.GetInteger("subdataContentId"),
parentFeatureId = csFeature.GetInteger("subparentFeatureId"),
};
feature.subFeatureList.Add(subFeature);
}
lastFeatureId = csFeature.GetInteger("id");
csFeature.GoNext();
} while (csFeature.OK());
csFeature.Close();
//
// -- populate parentFeatureGuid from parentFeatureId
foreach (var kvp in result.featureList)
{
PortalDataFeatureModel testFeature = kvp.Value;
if ((testFeature.parentFeatureId > 0) && string.IsNullOrEmpty(testFeature.parentFeatureGuid))
{
foreach (var searchFeature in result.featureList)
{
if (testFeature.parentFeatureId == searchFeature.Value.id)
{
//
testFeature.parentFeatureGuid = searchFeature.Value.guid;
break;
}
}
}
}
return(result);
}
}
//
// -- no features found, load default portal features
if (string.IsNullOrEmpty(defaultConfigJson))
{
//
// no default, fake a tab
//
result.featureList = new Dictionary <string, PortalDataFeatureModel>();
PortalDataFeatureModel feature = new PortalDataFeatureModel {
addonId = 0,
dataContentId = 0,
guid = "",
heading = "Sample",
id = 0,
name = "Demo",
parentFeatureId = 0,
sortOrder = "",
addPadding = false
};
return(result);
}
//
// legacy - load features from portal record alone
//
System.Web.Script.Serialization.JavaScriptSerializer msJson = new System.Web.Script.Serialization.JavaScriptSerializer();
result = msJson.Deserialize <PortalDataModel>(defaultConfigJson);
savePortalToDb(CP, result);
//
using (CPCSBaseClass featureCs = CP.CSNew()) {
if (!string.IsNullOrEmpty(result.defaultFeature.guid))
{
if (featureCs.Open("portal features", "ccguid=" + CP.Db.EncodeSQLText(result.defaultFeature.guid), "", true, "", 9999, 1))
{
result.defaultFeature = loadPortalFeatureFromCs(CP, featureCs);
}
featureCs.Close();
}
}
return(result);
}
} catch (Exception ex) {
CP.Site.ErrorReport(ex, "exception in loadPortal");
throw;
}
}
