//
public static string get(CoreController core)
{
try {
StringBuilderLegacyController result_reset = new StringBuilderLegacyController();
result_reset.add(AdminUIController.getHeaderTitleDescription("IIS Reset", "Reset the webserver."));
//
// Process the form
//
string Button = core.docProperties.getText("button");
if (Button == ButtonIISReset)
{
//
//
//
LogController.logDebug(core, "Restarting IIS");
core.webServer.redirect("" + cdnPrefix + "Popup/WaitForIISReset.htm", "Redirect to iis reset");
Thread.Sleep(2000);
var cmdDetail = new TaskModel.CmdDetailClass {
addonId = 0,
addonName = "GetForm_IISReset",
args = new Dictionary <string, string>()
};
TaskSchedulerController.addTaskToQueue(core, cmdDetail, false);
}
//
// Display form
//
return(AdminUIController.getToolForm(core, result_reset.text, ButtonCancel + "," + ButtonIISReset));
} catch (Exception ex) {
LogController.logError(core, ex);
return(string.Empty);
}
}
//=============================================================================
/// <summary>
/// Go through all Content Definitions and create appropriate tables and fields.
/// </summary>
/// <returns></returns>
public static string get(CoreController core)
{
string returnValue = "";
try {
Processor.Models.Domain.ContentMetadataModel metadata = null;
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
string[,] ContentNameArray = null;
int ContentNameCount = 0;
string TableName = null;
string ButtonList;
//
ButtonList = ButtonCancel + "," + ButtonRun;
//
Stream.add(AdminUIController.getHeaderTitleDescription("Synchronize Tables to Content Definitions", "This tools goes through all Content Definitions and creates any necessary Tables and Table Fields to support the Definition."));
//
if (core.docProperties.getText("Button") != "")
{
//
// Run Tools
//
Stream.add("Synchronizing Tables to Content Definitions<br>");
using (var csData = new CsModel(core)) {
csData.open("Content", "", "", false, 0, "id");
if (csData.ok())
{
do
{
metadata = Processor.Models.Domain.ContentMetadataModel.create(core, csData.getInteger("id"));
TableName = metadata.tableName;
Stream.add("Synchronizing Content " + metadata.name + " to table " + TableName + "<br>");
using (var db = new DbController(core, metadata.dataSourceName)) {
db.createSQLTable(TableName);
if (metadata.fields.Count > 0)
{
foreach (var keyValuePair in metadata.fields)
{
ContentFieldMetadataModel field = keyValuePair.Value;
Stream.add("...Field " + field.nameLc + "<br>");
db.createSQLTableField(TableName, field.nameLc, field.fieldTypeId);
}
}
}
csData.goNext();
} while (csData.ok());
ContentNameArray = csData.getRows();
ContentNameCount = ContentNameArray.GetUpperBound(1) + 1;
}
}
}
returnValue = AdminUIController.getToolForm(core, Stream.text, ButtonList);
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
}
return(returnValue);
}
//
//====================================================================================================
//
public override string GetAddLink(string contentName, string presetNameValueList)
{
string result = "";
foreach (var link in AdminUIController.getRecordAddAnchorTag(cp.core, contentName, presetNameValueList, false, true))
{
result += link;
}
return(result);
}
//
//====================================================================================================
//
public override string GetEditLink(int contentId, string recordGuid)
{
var contentMetadata = ContentMetadataModel.create(cp.core, contentId);
if (contentMetadata == null)
{
throw new GenericException("contentId [" + contentId + "], but no content metadata found.");
}
return(AdminUIController.getRecordEditAnchorTag(cp.core, contentMetadata, recordGuid));
}
//
//====================================================================================================
//
public override string GetEditLink(string contentName, string recordGuid)
{
var contentMetadata = ContentMetadataModel.createByUniqueName(cp.core, contentName);
if (contentMetadata == null)
{
throw new GenericException("ContentName [" + contentName + "], but no content metadata found with this name.");
}
return(AdminUIController.getRecordEditAnchorTag(cp.core, contentMetadata, recordGuid));
}
//
//====================================================================================================
//
public override string GetAddLink(string contentName, string presetNameValueList, bool allowPaste, bool isEditing)
{
string result = "";
foreach (var link in AdminUIController.getRecordAddAnchorTag(cp.core, contentName, presetNameValueList, allowPaste, isEditing))
{
result += link;
}
return(result);
}
//
//=============================================================================
// Print the See Also listing
// ContentName is the name of the parent table
// RecordID is the parent RecordID
//=============================================================================
//
public static string getSeeAlso(CoreController core)
{
try {
if (core.doc.pageController.page.id == 0)
{
return(string.Empty);
}
int SeeAlsoCount = 0;
string result = "";
using (var cs = new CsModel(core)) {
if (cs.open("See Also", "(RecordID=" + core.doc.pageController.page.id + ")"))
{
do
{
string link = cs.getText("Link");
if ((!string.IsNullOrWhiteSpace(link)) && (!link.Contains("://")))
{
link = core.webServer.requestProtocol + link;
}
string editAnchorTag = (!core.session.isEditing() ? "" : AdminUIController.getRecordEditAnchorTag(core, "See Also", cs.getInteger("ID")));
string pageAnchorTag = HtmlController.a(cs.getText("name"), HtmlController.encodeHtml(link));
string brief = cs.getText("Brief");
if (!string.IsNullOrEmpty(brief))
{
brief = HtmlController.p(brief, "ccListCopy");
}
result += HtmlController.li(editAnchorTag + pageAnchorTag + brief, "ccListItem");
SeeAlsoCount += 1;
cs.goNext();
} while (cs.ok());
}
}
if (core.session.isEditing())
{
SeeAlsoCount += 1;
foreach (var AddLink in AdminUIController.getRecordAddAnchorTag(core, "See Also", "RecordID=" + core.doc.pageController.page.id))
{
if (!string.IsNullOrEmpty(AddLink))
{
result += HtmlController.li(AddLink, "ccEditWrapper ccListItem");
}
}
}
if (SeeAlsoCount == 0)
{
return(string.Empty);
}
return(HtmlController.div(HtmlController.h4("See Also") + HtmlController.ul(result, "ccList"), "ccSeeAlso"));
} catch (Exception ex) {
LogController.logError(core, ex);
return(string.Empty);
}
}
//
//========================================================================
//
public static string get(CoreController core, AdminDataModel adminData)
{
string result = null;
try {
string editorRow = "";
editorRow = AdminUIEditorController.getGroupRuleEditor(core, adminData);
result = AdminUIController.getEditPanel(core, true, "Group Membership", "", editorRow);
adminData.editSectionPanelCount += 1;
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(result);
}
//=============================================================================
// Print the manual query form
//=============================================================================
//
private string GetForm_LogFiles(CoreController core)
{
string tempGetForm_LogFiles = null;
try {
string ButtonList = ButtonCancel;
tempGetForm_LogFiles = AdminUIController.getHeaderTitleDescription("Log File View", "This tool displays the Contensive Log Files.");
tempGetForm_LogFiles += "<P></P>";
//
string QueryOld = ".asp?";
string QueryNew = GenericController.modifyQueryString(QueryOld, RequestNameAdminForm, AdminFormToolLogFileView, true);
tempGetForm_LogFiles += GenericController.strReplace(GetForm_LogFiles_Details(core), QueryOld, QueryNew + "&", 1, 99, 1);
//
tempGetForm_LogFiles = AdminUIController.getToolForm(core, tempGetForm_LogFiles, ButtonList);
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(tempGetForm_LogFiles);
}
//
//=============================================================================
// Print the manual query form
//=============================================================================
//
private string GetForm_WebsiteFileManager(CoreController core)
{
string result = "";
try {
string InstanceOptionString = "AdminLayout=1&filesystem=website files";
AddonModel addon = DbBaseModel.create <AddonModel>(core.cpParent, "{B966103C-DBF4-4655-856A-3D204DEF6B21}");
string Content = core.addon.execute(addon, new BaseClasses.CPUtilsBaseClass.addonExecuteContext {
addonType = Contensive.BaseClasses.CPUtilsBaseClass.addonContext.ContextAdmin,
argumentKeyValuePairs = GenericController.convertQSNVAArgumentstoDocPropertiesList(core, InstanceOptionString),
instanceGuid = "-2",
errorContextMessage = "executing File Manager within website file manager"
});
string Description = "Manage files and folders within the Website's file area.";
string ButtonList = ButtonApply + "," + ButtonCancel;
result = AdminUIController.getToolBody(core, "Website File Manager", ButtonList, "", false, false, Description, "", 0, Content);
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(result);
}
//
public static string get(CoreController core)
{
try {
var result_guid = new StringBuilderLegacyController();
result_guid.add(AdminUIController.getHeaderTitleDescription("Create GUID", "Use this tool to create a GUID. This is useful when creating new Addons."));
//
// Process the form
string Button = core.docProperties.getText("button");
if (Button.Equals(ButtonCancel))
{
return(string.Empty);
}
//
result_guid.add(HtmlController.inputText_Legacy(core, "GUID", GenericController.getGUID(), 1, 80));
//
// Display form
return(AdminUIController.getToolForm(core, result_guid.text, ButtonCancel + "," + ButtonCreateGUId));
} catch (Exception ex) {
LogController.logError(core, ex);
return(string.Empty);
}
}
//
//====================================================================================================
/// <summary>
/// Run manual query
/// </summary>
/// <param name="cp"></param>
/// <returns></returns>
public static string get(CPClass cp)
{
string returnHtml = "";
CoreController core = cp.core;
try {
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
Stream.add(AdminUIController.getHeaderTitleDescription("Run Manual Query", "This tool runs an SQL statement on a selected datasource. If there is a result set, the set is printed in a table."));
//
// Get the members SQL Queue
//
string SQLFilename = core.userProperty.getText("SQLArchive");
if (string.IsNullOrEmpty(SQLFilename))
{
SQLFilename = "SQLArchive" + core.session.user.id.ToString("000000000") + ".txt";
core.userProperty.setProperty("SQLArchive", SQLFilename);
}
string SQLArchive = core.cdnFiles.readFileText(SQLFilename);
//
// Read in arguments if available
//
int Timeout = core.docProperties.getInteger("Timeout");
if (Timeout == 0)
{
Timeout = 30;
}
//
int pageSize = core.docProperties.getInteger("PageSize");
if (pageSize == 0)
{
pageSize = 10;
}
//
int pageNumber = core.docProperties.getInteger("PageNumber");
if (pageNumber == 0)
{
pageNumber = 1;
}
//
string SQL = core.docProperties.getText("SQL");
if (string.IsNullOrEmpty(SQL))
{
SQL = core.docProperties.getText("SQLList");
}
DataSourceModel datasource = DataSourceModel.create(core.cpParent, core.docProperties.getInteger("dataSourceid"));
//
if ((core.docProperties.getText("button")) == ButtonRun)
{
//
// Add this SQL to the members SQL list
//
if (!string.IsNullOrEmpty(SQL))
{
string SQLArchiveOld = SQLArchive.Replace(SQL + Environment.NewLine, "");
SQLArchive = SQL.Replace(Environment.NewLine, " ") + Environment.NewLine;
int LineCounter = 0;
while ((LineCounter < 10) && (!string.IsNullOrEmpty(SQLArchiveOld)))
{
string line = getLine(ref SQLArchiveOld).Trim();
if (!string.IsNullOrWhiteSpace(line))
{
SQLArchive += line + Environment.NewLine;
}
}
core.cdnFiles.saveFile(SQLFilename, SQLArchive);
}
//
// Run the SQL
//
string errBefore = ErrorController.getDocExceptionHtmlList(core);
if (!string.IsNullOrWhiteSpace(errBefore))
{
// -- error in interface, should be fixed before attempting query
Stream.add("<br>" + core.dateTimeNowMockable + " SQL NOT executed. The following errors were detected before execution");
Stream.add(errBefore);
}
else
{
Stream.add("<p>" + core.dateTimeNowMockable + " Executing sql [" + SQL + "] on DataSource [" + datasource.name + "]");
DataTable dt = null;
try {
dt = core.db.executeQuery(SQL, DbController.getStartRecord(pageSize, pageNumber), pageSize);
} catch (Exception ex) {
//
// ----- error
Stream.add("<br>" + core.dateTimeNowMockable + " SQL execution returned the following error");
Stream.add("<br>" + ex.Message);
}
string errSql = ErrorController.getDocExceptionHtmlList(core);
if (!string.IsNullOrWhiteSpace(errSql))
{
Stream.add("<br>" + core.dateTimeNowMockable + " SQL execution returned the following error");
Stream.add("<br>" + errSql);
core.doc.errorList.Clear();
}
else
{
Stream.add("<br>" + core.dateTimeNowMockable + " SQL executed successfully");
if (dt == null)
{
Stream.add("<br>" + core.dateTimeNowMockable + " SQL returned invalid data.");
}
else if (dt.Rows == null)
{
Stream.add("<br>" + core.dateTimeNowMockable + " SQL returned invalid data rows.");
}
else if (dt.Rows.Count == 0)
{
Stream.add("<br>" + core.dateTimeNowMockable + " The SQL returned no data.");
}
else
{
//
// ----- print results
//
Stream.add("<br>" + core.dateTimeNowMockable + " The following results were returned");
Stream.add("<br></p>");
//
// --- Create the Fields for the new table
//
int FieldCount = dt.Columns.Count;
Stream.add("<table class=\"table table-bordered table-hover table-sm table-striped\">");
Stream.add("<thead class=\"thead - inverse\"><tr>");
foreach (DataColumn dc in dt.Columns)
{
Stream.add("<th>" + dc.ColumnName + "</th>");
}
Stream.add("</tr></thead>");
//
string[,] resultArray = core.db.convertDataTabletoArray(dt);
//
int RowMax = resultArray.GetUpperBound(1);
int ColumnMax = resultArray.GetUpperBound(0);
string RowStart = "<tr>";
string RowEnd = "</tr>";
string ColumnStart = "<td>";
string ColumnEnd = "</td>";
int RowPointer = 0;
for (RowPointer = 0; RowPointer <= RowMax; RowPointer++)
{
Stream.add(RowStart);
int ColumnPointer = 0;
for (ColumnPointer = 0; ColumnPointer <= ColumnMax; ColumnPointer++)
{
string CellData = resultArray[ColumnPointer, RowPointer];
if (isNull(CellData))
{
Stream.add(ColumnStart + "[null]" + ColumnEnd);
}
else if (string.IsNullOrEmpty(CellData))
{
Stream.add(ColumnStart + "[empty]" + ColumnEnd);
}
else
{
Stream.add(ColumnStart + HtmlController.encodeHtml(GenericController.encodeText(CellData)) + ColumnEnd);
}
}
Stream.add(RowEnd);
}
Stream.add("</table>");
}
}
}
Stream.add("<p>" + core.dateTimeNowMockable + " Done</p>");
}
//
// Display form
{
//
// -- sql form
int SQLRows = core.docProperties.getInteger("SQLRows");
if (SQLRows == 0)
{
SQLRows = core.userProperty.getInteger("ManualQueryInputRows", 5);
}
else
{
core.userProperty.setProperty("ManualQueryInputRows", SQLRows.ToString());
}
Stream.add(AdminUIEditorController.getHtmlCodeEditor(core, "SQL", SQL, false, "SQL", false));
Stream.add(" <INPUT TYPE=\"Text\" TabIndex=-1 NAME=\"SQLRows\" SIZE=\"3\" VALUE=\"" + SQLRows + "\" ID=\"\" onchange=\"SQL.rows=SQLRows.value; return true\"> Rows");
}
//
// -- data source
bool isEmptyList = false;
Stream.add(AdminUIController.getToolFormInputRow(core, "Data Source", AdminUIEditorController.getLookupContentEditor(core, "DataSourceID", datasource.id, ContentMetadataModel.getContentId(core, "data sources"), ref isEmptyList, false, "", "", false, "")));
{
//
// -- sql list
string js = "var e = document.getElementById('SQLList');SQL.value=e.options[e.selectedIndex].text;";
List <string> lookupList = SQLArchive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
string inputSelect = AdminUIEditorController.getLookupListEditor(core, "SQLList", 0, lookupList, false, "SQLList", "", false);
inputSelect = inputSelect.Replace("<select ", "<select onChange=\"" + js + "\" ");
Stream.add(AdminUIController.getToolFormInputRow(core, "Previous Queries", inputSelect));
}
//
// -- page size
if (isNull(pageSize))
{
pageSize = 100;
}
Stream.add(AdminUIController.getToolFormInputRow(core, "Page Size", AdminUIEditorController.getTextEditor(core, "PageSize", pageSize.ToString())));
//
// -- page number
if (isNull(pageNumber))
{
pageNumber = 1;
}
Stream.add(AdminUIController.getToolFormInputRow(core, "Page Number", AdminUIEditorController.getTextEditor(core, "PageNumber", pageNumber.ToString())));
//
// -- timeout
if (isNull(Timeout))
{
Timeout = 30;
}
Stream.add(AdminUIController.getToolFormInputRow(core, "Timeout (sec)", AdminUIEditorController.getTextEditor(core, "Timeout", Timeout.ToString())));
//
// -- assemble form
returnHtml = AdminUIController.getToolForm(core, Stream.text, ButtonCancel + "," + ButtonRun);
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
}
return(returnHtml);
}
//
/// <summary>
///
/// </summary>
/// <param name="cp"></param>
/// <returns></returns>
//
public static string sampleTool(CPClass cp)
{
string result = "";
CoreController core = cp.core;
try {
var resultForm = new StringBuilder();
resultForm.Append(AdminUIController.getHeaderTitleDescription("Sample Tool", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Erat imperdiet sed euismod nisi. In vitae turpis massa sed elementum tempus egestas sed sed. Tortor consequat id porta nibh. Pulvinar sapien et ligula ullamcorper malesuada. Facilisi nullam vehicula ipsum a. Nibh venenatis cras sed felis eget. Lectus magna fringilla urna porttitor rhoncus dolor. Auctor urna nunc id cursus metus aliquam. Gravida neque convallis a cras semper auctor neque. Faucibus nisl tincidunt eget nullam non nisi est sit amet. In nisl nisi scelerisque eu ultrices vitae auctor eu augue. In egestas erat imperdiet sed euismod nisi. Adipiscing diam donec adipiscing tristique. Ullamcorper eget nulla facilisi etiam dignissim diam quis enim. Sed libero enim sed faucibus turpis in eu. Ultrices neque ornare aenean euismod elementum nisi quis eleifend."));
//
// process form
string button = cp.Doc.GetText("button");
string PageSize = cp.Doc.GetText("pageSize");
int countryId = cp.Doc.GetInteger("countryId");
var buttonList = new List <string> {
ButtonCancel
};
if (button == ButtonCancel)
{
//
// Cancel just exits with no content
//
return(string.Empty);
}
else if (!core.session.isAuthenticatedAdmin())
{
//
// Not Admin Error
//
resultForm.Append(AdminUIController.getFormBodyAdminOnly());
}
else
{
//
// Process Requests
//
switch (button)
{
case ButtonSave:
case ButtonOK: {
//
// perform action
break;
}
default: {
// nothing
break;
}
}
if (button.Equals(ButtonOK))
{
//
// Exit on OK
//
return(string.Empty);
}
}
//
// display form
resultForm.Append(cp.Html5.P("Enter sample data."));
resultForm.Append(HtmlController.inputTextarea(core, "sampleText", "", 10));
//
// Buttons
//
buttonList.Add(ButtonSave);
buttonList.Add(ButtonOK);
//
// Close Tables
//
resultForm.Append(HtmlController.inputHidden(rnAdminSourceForm, AdminFormSecurityControl));
bool isEmptyList = false;
resultForm.Append(AdminUIController.getToolFormInputRow(core, "Caption", AdminUIEditorController.getLookupContentEditor(core, "countryId", countryId, ContentMetadataModel.getContentId(core, "countries"), ref isEmptyList, false, "", "", false, "")));
resultForm.Append(AdminUIController.getToolFormInputRow(core, "Caption", AdminUIEditorController.getTextEditor(core, "PageSize", PageSize.ToString())));
//
// -- assemble form
result = AdminUIController.getToolForm(core, resultForm.ToString(), String.Join(",", buttonList));
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
}
return(result);
}
//
//========================================================================
/// <summary>
/// Control edit tab
/// </summary>
/// <param name="core"></param>
/// <param name="adminData"></param>
/// <returns></returns>
public static string get(CoreController core, AdminDataModel adminData, EditorEnvironmentModel editorEnv)
{
string result = null;
try {
bool disabled = false;
//
var tabPanel = new StringBuilderLegacyController();
if (string.IsNullOrEmpty(adminData.adminContent.name))
{
//
// Content not found or not loaded
if (adminData.adminContent.id == 0)
{
//
LogController.logError(core, new GenericException("No content definition was specified for this page"));
return(HtmlController.p("No content was specified."));
}
else
{
//
// Content Definition was not specified
LogController.logError(core, new GenericException("The content definition specified for this page [" + adminData.adminContent.id + "] was not found"));
return(HtmlController.p("No content was specified."));
}
}
//
// ----- Authoring status
bool FieldRequired = false;
List <string> TabsFound = new List <string>();
foreach (KeyValuePair <string, ContentFieldMetadataModel> keyValuePair in adminData.adminContent.fields)
{
ContentFieldMetadataModel field = keyValuePair.Value;
if ((field.editTabName.ToLowerInvariant().Equals("control info")) && (field.authorable) && (field.active))
{
tabPanel.add(EditorRowClass.getEditorRow(core, field, adminData, editorEnv));
}
}
//
// ----- RecordID
{
string fieldValue = (adminData.editRecord.id == 0) ? "(available after save)" : adminData.editRecord.id.ToString();
string fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore", fieldValue, true, "");
string fieldHelp = "This is the unique number that identifies this record within this content.";
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Record Number", fieldHelp, true, false, ""));
}
//
// -- Active
{
string htmlId = "fieldActive";
string fieldEditor = HtmlController.checkbox("active", adminData.editRecord.active, htmlId, disabled, "", adminData.editRecord.userReadOnly);
string fieldHelp = "When unchecked, add-ons can ignore this record as if it was temporarily deleted.";
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Active", fieldHelp, false, false, htmlId));
}
//
// -- GUID
{
string guidSetHtmlId = "guidSet" + GenericController.getRandomInteger(core).ToString();
string guidInputHtmlId = "guidInput" + GenericController.getRandomInteger(core).ToString();
string fieldValue = GenericController.encodeText(adminData.editRecord.fieldsLc["ccguid"].value);
string fieldEditor = "";
if (adminData.editRecord.userReadOnly)
{
//
// -- readonly
fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore", fieldValue, true, "");
}
else if (string.IsNullOrEmpty(fieldValue))
{
//
// add a set button
string setButton = "<input id=\"" + guidSetHtmlId + "\" type=\"submit\" value=\"Set\" class=\"btn btn-primary btn-sm\">";
string setButtonWrapped = "<div class=\"input-group-append\">" + setButton + "</div>";
string inputCell = AdminUIEditorController.getTextEditor(core, "ccguid", "", false, guidInputHtmlId);
fieldEditor = HtmlController.div(inputCell + setButtonWrapped, "input-group");
string newGuid = GenericController.getGUID(true);
string onClickFn = "function(e){e.preventDefault();e.stopPropagation();$('#" + guidInputHtmlId + "').val('" + newGuid + "');}";
string script = "$('body').on('click','#" + guidSetHtmlId + "'," + onClickFn + ")";
core.html.addScriptCode(script, "Admin edit control-info-tab guid set button");
}
else
{
//
// field is read-only except for developers
fieldEditor = AdminUIEditorController.getTextEditor(core, "ccguid", fieldValue, !core.session.isAuthenticatedDeveloper(), guidInputHtmlId);
}
string FieldHelp = "This is a unique number that identifies this record globally. A GUID is not required, but when set it should never be changed. GUIDs are used to synchronize records. When empty, you can create a new guid. Only Developers can modify the guid.";
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "GUID", FieldHelp, false, false, guidInputHtmlId));
}
//
// ----- EID (Encoded ID)
{
if (GenericController.toUCase(adminData.adminContent.tableName) == GenericController.toUCase("ccMembers"))
{
string htmlId = "fieldGuid";
bool AllowEId = (core.siteProperties.getBoolean("AllowLinkLogin", true)) || (core.siteProperties.getBoolean("AllowLinkRecognize", true));
string fieldHelp = "This string is an authentication token that can be used in the URL for the next 15 minutes to log in as this user.";
string fieldEditor = "";
if (!AllowEId)
{
fieldEditor = "(link login and link recognize are disabled in security preferences)";
}
else if (adminData.editRecord.id == 0)
{
fieldEditor = "(available after save)";
}
else
{
string eidQueryString = "eid=" + WebUtility.UrlEncode(SecurityController.encodeToken(core, adminData.editRecord.id, core.doc.profileStartTime.AddMinutes(15)));
string sampleUrl = core.webServer.requestProtocol + core.webServer.requestDomain + "/" + core.siteProperties.serverPageDefault + "?" + eidQueryString;
if (core.siteProperties.getBoolean("AllowLinkLogin", true))
{
fieldHelp = " If " + eidQueryString + " is added to a url querystring for this site, the user be logged in as this person.";
}
else
{
fieldHelp = " If " + eidQueryString + " is added to a url querystring for this site, the user be recognized in as this person, but not logged in.";
}
fieldHelp += " To enable, disable or modify this feature, use the security tab on the Preferences page.";
fieldHelp += "<br>For example: " + sampleUrl;
fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore_eid", eidQueryString, true, htmlId);
}
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Member Link Login Querystring", fieldHelp, true, false, htmlId));
}
}
//
// ----- Controlling Content
{
string HTMLFieldString = "";
string FieldHelp = "The content in which this record is stored. This is similar to a database table.";
ContentFieldMetadataModel field = null;
if (adminData.adminContent.fields.ContainsKey("contentcontrolid"))
{
field = adminData.adminContent.fields["contentcontrolid"];
//
// if this record has a parent id, only include CDefs compatible with the parent record - otherwise get all for the table
FieldHelp = GenericController.encodeText(field.helpMessage);
FieldRequired = GenericController.encodeBoolean(field.required);
int FieldValueInteger = (adminData.editRecord.contentControlId.Equals(0)) ? adminData.adminContent.id : adminData.editRecord.contentControlId;
if (!core.session.isAuthenticatedAdmin())
{
HTMLFieldString = HTMLFieldString + HtmlController.inputHidden("contentControlId", FieldValueInteger);
}
else
{
string RecordContentName = adminData.editRecord.contentControlId_Name;
string TableName2 = MetadataController.getContentTablename(core, RecordContentName);
int TableId = MetadataController.getRecordIdByUniqueName(core, "Tables", TableName2);
//
// Test for parentid
int ParentId = 0;
bool ContentSupportsParentId = false;
if (adminData.editRecord.id > 0)
{
using (var csData = new CsModel(core)) {
if (csData.openRecord(RecordContentName, adminData.editRecord.id))
{
ContentSupportsParentId = csData.isFieldSupported("ParentID");
if (ContentSupportsParentId)
{
ParentId = csData.getInteger("ParentID");
}
}
}
}
bool IsEmptyList = false;
if (core.session.isAuthenticatedAdmin())
{
//
// administrator, and either ( no parentid or does not support it), let them select any content compatible with the table
string sqlFilter = "(ContentTableID=" + TableId + ")";
int contentCId = MetadataController.getRecordIdByUniqueName(core, ContentModel.tableMetadata.contentName, ContentModel.tableMetadata.contentName);
HTMLFieldString += AdminUIEditorController.getLookupContentEditor(core, "contentcontrolid", FieldValueInteger, contentCId, ref IsEmptyList, adminData.editRecord.userReadOnly, "", "", true, sqlFilter);
FieldHelp = FieldHelp + " (Only administrators have access to this control. Changing the Controlling Content allows you to change who can author the record, as well as how it is edited.)";
}
}
}
if (string.IsNullOrEmpty(HTMLFieldString))
{
HTMLFieldString = adminData.editRecord.contentControlId_Name;
}
tabPanel.add(AdminUIController.getEditRow(core, HTMLFieldString, "Controlling Content", FieldHelp, FieldRequired, false, ""));
}
//
// ----- Created By
{
string FieldHelp = "The people account of the user who created this record.";
string fieldValue = "";
if (adminData.editRecord == null)
{
fieldValue = "(not set)";
}
else if (adminData.editRecord.id == 0)
{
fieldValue = "(available after save)";
}
else if (adminData.editRecord.createdBy == null)
{
fieldValue = "(not set)";
}
else
{
int FieldValueInteger = adminData.editRecord.createdBy.id;
if (FieldValueInteger == 0)
{
fieldValue = "(not set)";
}
else
{
using (var csData = new CsModel(core)) {
csData.open("people", "(id=" + FieldValueInteger + ")", "name,active", false);
if (!csData.ok())
{
fieldValue = "#" + FieldValueInteger + ", (deleted)";
}
else
{
fieldValue = "#" + FieldValueInteger + ", " + csData.getText("name");
if (!csData.getBoolean("active"))
{
fieldValue += " (inactive)";
}
}
csData.close();
}
}
}
string fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore_createdBy", fieldValue, true, "");
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Created By", FieldHelp, FieldRequired, false, ""));
}
//
// ----- Created Date
{
string FieldHelp = "The date and time when this record was originally created.";
string fieldValue = "";
if (adminData.editRecord == null)
{
fieldValue = "(not set)";
}
else if (adminData.editRecord.id == 0)
{
fieldValue = "(available after save)";
}
else
{
if (GenericController.encodeDateMinValue(adminData.editRecord.dateAdded) == DateTime.MinValue)
{
fieldValue = "(not set)";
}
else
{
fieldValue = adminData.editRecord.dateAdded.ToString();
}
}
string fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore_createdDate", fieldValue, true, "");
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Created Date", FieldHelp, FieldRequired, false, ""));
}
//
// ----- Modified By
{
string FieldHelp = "The people account of the last user who modified this record.";
string fieldValue = "";
if (adminData.editRecord == null)
{
fieldValue = "(not set)";
}
else if (adminData.editRecord.id == 0)
{
fieldValue = "(available after save)";
}
else if (adminData.editRecord.modifiedBy == null)
{
fieldValue = "(not set)";
}
else
{
int FieldValueInteger = adminData.editRecord.modifiedBy.id;
if (FieldValueInteger == 0)
{
fieldValue = "(not set)";
}
else
{
using (var csData = new CsModel(core)) {
csData.open("people", "(id=" + FieldValueInteger + ")", "name,active", false);
if (!csData.ok())
{
fieldValue = "#" + FieldValueInteger + ", (deleted)";
}
else
{
fieldValue = "#" + FieldValueInteger + ", " + csData.getText("name");
if (!csData.getBoolean("active"))
{
fieldValue += " (inactive)";
}
}
csData.close();
}
}
}
string fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore_modifiedBy", fieldValue, true, "");
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Modified By", FieldHelp, FieldRequired, false, ""));
}
//
// ----- Modified Date
{
string FieldHelp = "The date and time when this record was last modified.";
string fieldValue = "";
if (adminData.editRecord == null)
{
fieldValue = "(not set)";
}
else if (adminData.editRecord.id == 0)
{
fieldValue = "(available after save)";
}
else
{
if (GenericController.encodeDateMinValue(adminData.editRecord.modifiedDate) == DateTime.MinValue)
{
fieldValue = "(not set)";
}
else
{
fieldValue = adminData.editRecord.modifiedDate.ToString();
}
}
string fieldEditor = AdminUIEditorController.getTextEditor(core, "ignore_modifiedBy", fieldValue, true, "");
tabPanel.add(AdminUIController.getEditRow(core, fieldEditor, "Modified Date", FieldHelp, false, false, ""));
}
string s = AdminUIController.editTable(tabPanel.text);
result = AdminUIController.getEditPanel(core, true, "Control Information", "", s);
adminData.editSectionPanelCount += 1;
tabPanel = null;
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(result);
}
//
//=============================================================================
// Find and Replace launch tool
//=============================================================================
//
public static string get(CoreController core)
{
string result = "";
try {
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
//
Stream.add(AdminUIController.getHeaderTitleDescription("Find and Replace", "This tool runs a find and replace operation on content throughout the site."));
//
// Process the form
//
string Button = core.docProperties.getText("button");
bool IsDeveloper = core.session.isAuthenticatedDeveloper();
int RowPtr = 0;
string CDefList = "";
string FindText = "";
string ReplaceText = "";
string lcName = null;
if (Button == ButtonFindAndReplace)
{
int RowCnt = core.docProperties.getInteger("CDefRowCnt");
if (RowCnt > 0)
{
for (RowPtr = 0; RowPtr < RowCnt; RowPtr++)
{
if (core.docProperties.getBoolean("Cdef" + RowPtr))
{
lcName = GenericController.toLCase(core.docProperties.getText("CDefName" + RowPtr));
if (IsDeveloper || (lcName == "page content") || (lcName == "copy content") || (lcName == "page templates"))
{
CDefList = CDefList + "," + lcName;
}
}
}
if (!string.IsNullOrEmpty(CDefList))
{
CDefList = CDefList.Substring(1);
}
FindText = core.docProperties.getText("FindText");
ReplaceText = core.docProperties.getText("ReplaceText");
//string QS = "app=" + encodeNvaArgument(core.appConfig.name) + "&FindText=" + encodeNvaArgument(FindText) + "&ReplaceText=" + encodeNvaArgument(ReplaceText) + "&CDefNameList=" + encodeNvaArgument(CDefList);
var cmdDetail = new TaskModel.CmdDetailClass {
addonId = 0,
addonName = "GetForm_FindAndReplace",
args = new System.Collections.Generic.Dictionary <string, string> {
{ "app", core.appConfig.name },
{ "FindText", FindText },
{ "ReplaceText", ReplaceText },
{ "CDefNameList", CDefList }
}
};
TaskSchedulerController.addTaskToQueue(core, cmdDetail, false);
Stream.add("Find and Replace has been requested for content definitions [" + CDefList + "], finding [" + FindText + "] and replacing with [" + ReplaceText + "]");
}
}
else
{
CDefList = "Page Content,Copy Content,Page Templates";
FindText = "";
ReplaceText = "";
}
//
// Display form
//
int FindRows = core.docProperties.getInteger("SQLRows");
if (FindRows == 0)
{
FindRows = core.userProperty.getInteger("FindAndReplaceFindRows", 1);
}
else
{
core.userProperty.setProperty("FindAndReplaceFindRows", FindRows.ToString());
}
int ReplaceRows = core.docProperties.getInteger("ReplaceRows");
if (ReplaceRows == 0)
{
ReplaceRows = core.userProperty.getInteger("FindAndReplaceReplaceRows", 1);
}
else
{
core.userProperty.setProperty("FindAndReplaceReplaceRows", ReplaceRows.ToString());
}
//
Stream.add("<div>Find</div>");
Stream.add("<TEXTAREA NAME=\"FindText\" ROWS=\"" + FindRows + "\" ID=\"FindText\" STYLE=\"width: 800px;\">" + FindText + "</TEXTAREA>");
Stream.add(" <INPUT TYPE=\"Text\" TabIndex=-1 NAME=\"FindTextRows\" SIZE=\"3\" VALUE=\"" + FindRows + "\" ID=\"\" onchange=\"FindText.rows=FindTextRows.value; return true\"> Rows");
Stream.add("<br><br>");
//
Stream.add("<div>Replace it with</div>");
Stream.add("<TEXTAREA NAME=\"ReplaceText\" ROWS=\"" + ReplaceRows + "\" ID=\"ReplaceText\" STYLE=\"width: 800px;\">" + ReplaceText + "</TEXTAREA>");
Stream.add(" <INPUT TYPE=\"Text\" TabIndex=-1 NAME=\"ReplaceTextRows\" SIZE=\"3\" VALUE=\"" + ReplaceRows + "\" ID=\"\" onchange=\"ReplaceText.rows=ReplaceTextRows.value; return true\"> Rows");
Stream.add("<br><br>");
string TopHalf = "";
string BottomHalf = "";
//
using (var csData = new CsModel(core)) {
csData.open("Content");
while (csData.ok())
{
string RecordName = csData.getText("Name");
lcName = GenericController.toLCase(RecordName);
if (IsDeveloper || (lcName == "page content") || (lcName == "copy content") || (lcName == "page templates"))
{
int RecordId = csData.getInteger("ID");
if (GenericController.strInstr(1, "," + CDefList + ",", "," + RecordName + ",") != 0)
{
TopHalf = TopHalf + "<div>" + HtmlController.checkbox("Cdef" + RowPtr, true) + HtmlController.inputHidden("CDefName" + RowPtr, RecordName) + " " + csData.getText("Name") + "</div>";
}
else
{
BottomHalf = BottomHalf + "<div>" + HtmlController.checkbox("Cdef" + RowPtr, false) + HtmlController.inputHidden("CDefName" + RowPtr, RecordName) + " " + csData.getText("Name") + "</div>";
}
}
csData.goNext();
RowPtr += 1;
}
}
Stream.add(TopHalf + BottomHalf + HtmlController.inputHidden("CDefRowCnt", RowPtr));
//
result = AdminUIController.getToolForm(core, Stream.text, ButtonCancel + "," + ButtonFindAndReplace);
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(result);
}
//
//====================================================================================================
//
public override string GetEditWrapper(string innerHtml, int contentId, string recordGuid)
{
return(AdminUIController.getEditWrapper(cp.core, innerHtml, contentId, recordGuid));
}
//
//=============================================================================
// Create a child content
//=============================================================================
//
public static string get(CPClass cp)
{
string result = "";
try {
//
bool IsEmptyList = false;
int ParentContentId = 0;
string ChildContentName = "";
int ChildContentId = 0;
bool AddAdminMenuEntry = false;
StringBuilderLegacyController Content = new StringBuilderLegacyController();
string FieldValue = null;
bool NewGroup = false;
int GroupId = 0;
string NewGroupName = "";
string Button = null;
string Caption = null;
string Description = "";
string ButtonList = "";
bool BlockForm = false;
//
Button = cp.core.docProperties.getText(RequestNameButton);
if (Button == ButtonCancel)
{
//
//
//
return(cp.core.webServer.redirect("/" + cp.core.appConfig.adminRoute, "GetContentChildTool, Cancel Button Pressed"));
}
else if (!cp.core.session.isAuthenticatedAdmin())
{
//
//
//
ButtonList = ButtonCancel;
Content.add(AdminUIController.getFormBodyAdminOnly());
}
else
{
//
if (Button != ButtonOK)
{
//
// Load defaults
//
ParentContentId = cp.core.docProperties.getInteger("ParentContentID");
if (ParentContentId == 0)
{
ParentContentId = ContentMetadataModel.getContentId(cp.core, "Page Content");
}
AddAdminMenuEntry = true;
GroupId = 0;
}
else
{
//
// Process input
//
ParentContentId = cp.core.docProperties.getInteger("ParentContentID");
var parentContentMetadata = ContentMetadataModel.create(cp.core, ParentContentId);
ChildContentName = cp.core.docProperties.getText("ChildContentName");
AddAdminMenuEntry = cp.core.docProperties.getBoolean("AddAdminMenuEntry");
GroupId = cp.core.docProperties.getInteger("GroupID");
NewGroup = cp.core.docProperties.getBoolean("NewGroup");
NewGroupName = cp.core.docProperties.getText("NewGroupName");
//
if ((parentContentMetadata == null) || (string.IsNullOrEmpty(ChildContentName)))
{
Processor.Controllers.ErrorController.addUserError(cp.core, "You must select a parent and provide a child name.");
}
else
{
//
// Create Definition
//
Description = Description + "<div> </div>"
+ "<div>Creating content [" + ChildContentName + "] from [" + parentContentMetadata.name + "]</div>";
var childContentMetadata = parentContentMetadata.createContentChild(cp.core, ChildContentName, cp.core.session.user.id);
ChildContentId = ContentMetadataModel.getContentId(cp.core, ChildContentName);
//
// Create Group and Rule
//
if (NewGroup && (!string.IsNullOrEmpty(NewGroupName)))
{
using (var csData = new CsModel(cp.core)) {
csData.open("Groups", "name=" + DbController.encodeSQLText(NewGroupName));
if (csData.ok())
{
Description = Description + "<div>Group [" + NewGroupName + "] already exists, using existing group.</div>";
GroupId = csData.getInteger("ID");
}
else
{
Description = Description + "<div>Creating new group [" + NewGroupName + "]</div>";
csData.close();
csData.insert("Groups");
if (csData.ok())
{
GroupId = csData.getInteger("ID");
csData.set("Name", NewGroupName);
csData.set("Caption", NewGroupName);
}
}
}
}
if (GroupId != 0)
{
using (var csData = new CsModel(cp.core)) {
csData.insert("Group Rules");
if (csData.ok())
{
Description = Description + "<div>Assigning group [" + MetadataController.getRecordName(cp.core, "Groups", GroupId) + "] to edit content [" + ChildContentName + "].</div>";
csData.set("GroupID", GroupId);
csData.set("ContentID", ChildContentId);
}
}
}
//
// Add Admin Menu Entry
//
if (AddAdminMenuEntry)
{
//
// Add Navigator entries
}
//
Description = Description + "<div> </div>"
+ "<div>Your new content is ready. <a href=\"?" + rnAdminForm + "=22\">Click here</a> to create another Content Definition, or hit [Cancel] to return to the main menu.</div>";
ButtonList = ButtonCancel;
BlockForm = true;
}
cp.core.clearMetaData();
cp.core.cache.invalidateAll();
}
//
// Get the form
//
if (!BlockForm)
{
string tableBody = "";
//
FieldValue = "<select size=\"1\" name=\"ParentContentID\" ID=\"\"><option value=\"\">Select One</option>";
FieldValue = FieldValue + GetContentChildTool_Options(cp, 0, ParentContentId);
FieldValue = FieldValue + "</select>";
tableBody += AdminUIController.getEditRowLegacy(cp.core, FieldValue, "Parent Content Name", "", false, false, "");
//
FieldValue = HtmlController.inputText_Legacy(cp.core, "ChildContentName", ChildContentName, 1, 40);
tableBody += AdminUIController.getEditRowLegacy(cp.core, FieldValue, "New Child Content Name", "", false, false, "");
//
FieldValue = ""
+ HtmlController.inputRadio("NewGroup", false.ToString(), NewGroup.ToString()) + cp.core.html.selectFromContent("GroupID", GroupId, "Groups", "", "", "", ref IsEmptyList) + "(Select a current group)"
+ "<br>" + HtmlController.inputRadio("NewGroup", true.ToString(), NewGroup.ToString()) + HtmlController.inputText_Legacy(cp.core, "NewGroupName", NewGroupName) + "(Create a new group)";
tableBody += AdminUIController.getEditRowLegacy(cp.core, FieldValue, "Content Manager Group", "", false, false, "");
//
Content.add(AdminUIController.editTable(tableBody));
Content.add("</td></tr>" + kmaEndTable);
//
ButtonList = ButtonOK + "," + ButtonCancel;
}
Content.add(HtmlController.inputHidden(rnAdminSourceForm, AdminFormContentChildTool));
}
//
Caption = "Create Content Definition";
Description = "<div>This tool is used to create content definitions that help segregate your content into authorable segments.</div>" + Description;
result = AdminUIController.getToolBody(cp.core, Caption, ButtonList, "", false, false, Description, "", 0, Content.text);
} catch (Exception ex) {
LogController.logError(cp.core, ex);
}
return(result);
}
//
//====================================================================================================
//
public override string GetEditLink(string contentName, int recordId)
{
return(AdminUIController.getRecordEditAndCutAnchorTag(cp.core, contentName, recordId, false, ""));
}
//
// ====================================================================================================
/// <summary>
/// Generate the content of a tab in the Edit Screen
/// </summary>
/// <param name="core"></param>
/// <param name="adminData"></param>
/// <param name="RecordID"></param>
/// <param name="ContentID"></param>
/// <param name="record_readOnly"></param>
/// <param name="IsLandingPage"></param>
/// <param name="IsRootPage"></param>
/// <param name="EditTab"></param>
/// <param name="EditorContext"></param>
/// <param name="return_NewFieldList"></param>
/// <param name="HelpCnt"></param>
/// <param name="HelpIDCache"></param>
/// <param name="helpDefaultCache"></param>
/// <param name="HelpCustomCache"></param>
/// <param name="AllowHelpMsgCustom"></param>
/// <param name="helpIdIndex"></param>
/// <returns></returns>
public static string getTab(CoreController core, AdminDataModel adminData, EditorEnvironmentModel editorEnv, int RecordID, int ContentID, string EditTab)
{
string returnHtml = "";
try {
//
// ----- Open the panel
if (adminData.adminContent.fields.Count <= 0)
{
//
// There are no visible fiels, return empty
LogController.logError(core, new GenericException("There is no metadata for this field."));
}
else
{
//
// ----- Build an index to sort the fields by EditSortOrder
Dictionary <string, ContentFieldMetadataModel> sortingFields = new Dictionary <string, ContentFieldMetadataModel>();
foreach (var keyValuePair in adminData.adminContent.fields)
{
ContentFieldMetadataModel field = keyValuePair.Value;
if (field.editTabName.ToLowerInvariant() == EditTab.ToLowerInvariant())
{
if (AdminDataModel.isVisibleUserField(core, field.adminOnly, field.developerOnly, field.active, field.authorable, field.nameLc, adminData.adminContent.tableName))
{
string AlphaSort = GenericController.getIntegerString(field.editSortPriority, 10) + "-" + GenericController.getIntegerString(field.id, 10);
sortingFields.Add(AlphaSort, field);
}
}
}
//
// ----- display the record fields
bool AllowHelpIcon = core.visitProperty.getBoolean("AllowHelpIcon");
StringBuilderLegacyController resultBody = new StringBuilderLegacyController();
bool needUniqueEmailMessage = false;
foreach (var kvp in sortingFields)
{
ContentFieldMetadataModel field = kvp.Value;
string editorRow = EditorRowClass.getEditorRow(core, field, adminData, editorEnv);
resultBody.add("<tr><td colspan=2>" + editorRow + "</td></tr>");
}
//
// ----- add the *Required Fields footer
resultBody.add("<tr><td colspan=2 style=\"padding-top:10px;font-size:70%\"><div>* Field is required.</div><div>** Field must be unique.</div>");
if (needUniqueEmailMessage)
{
resultBody.add("<div>*** Field must be unique because this site allows login by email.</div>");
}
resultBody.add("</td></tr>");
//
// ----- close the panel
returnHtml = AdminUIController.getEditPanel(core, false, "", "", AdminUIController.editTable(resultBody.text));
adminData.editSectionPanelCount += 1;
resultBody = null;
}
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
}
return(returnHtml);
}
//
//========================================================================
//
//========================================================================
//
public static string get(CPClass cp)
{
string tempGetForm_HouseKeepingControl = null;
try {
//
StringBuilderLegacyController Content = new StringBuilderLegacyController();
string Copy = null;
string SQL = null;
string Button = null;
int PagesTotal = 0;
string Caption = null;
DateTime DateValue = default(DateTime);
string AgeInDays = null;
int ArchiveRecordAgeDays = 0;
string ArchiveTimeOfDay = null;
bool ArchiveAllowFileClean = false;
string ButtonList = "";
string Description = null;
//
Button = cp.core.docProperties.getText(RequestNameButton);
if (Button == ButtonCancel)
{
//
//
//
return(cp.core.webServer.redirect("/" + cp.core.appConfig.adminRoute, "HouseKeepingControl, Cancel Button Pressed"));
}
else if (!cp.core.session.isAuthenticatedAdmin())
{
//
//
//
ButtonList = ButtonCancel;
Content.add(AdminUIController.getFormBodyAdminOnly());
}
else
{
//
string tableBody = "";
//
// Set defaults
//
ArchiveRecordAgeDays = (cp.core.siteProperties.getInteger("ArchiveRecordAgeDays", 0));
ArchiveTimeOfDay = cp.core.siteProperties.getText("ArchiveTimeOfDay", "12:00:00 AM");
ArchiveAllowFileClean = (cp.core.siteProperties.getBoolean("ArchiveAllowFileClean", false));
//
// Process Requests
//
switch (Button)
{
case ButtonOK:
case ButtonSave:
//
ArchiveRecordAgeDays = cp.core.docProperties.getInteger("ArchiveRecordAgeDays");
cp.core.siteProperties.setProperty("ArchiveRecordAgeDays", GenericController.encodeText(ArchiveRecordAgeDays));
//
ArchiveTimeOfDay = cp.core.docProperties.getText("ArchiveTimeOfDay");
cp.core.siteProperties.setProperty("ArchiveTimeOfDay", ArchiveTimeOfDay);
//
ArchiveAllowFileClean = cp.core.docProperties.getBoolean("ArchiveAllowFileClean");
cp.core.siteProperties.setProperty("ArchiveAllowFileClean", GenericController.encodeText(ArchiveAllowFileClean));
break;
}
//
if (Button == ButtonOK)
{
return(cp.core.webServer.redirect("/" + cp.core.appConfig.adminRoute, "StaticPublishControl, OK Button Pressed"));
}
//
// ----- Status
//
tableBody += HtmlController.tableRowStart() + "<td colspan=\"3\" class=\"ccPanel3D ccAdminEditSubHeader\"><b>Status</b>" + tableCellEnd + kmaEndTableRow;
//
// ----- Visits Found
//
PagesTotal = 0;
SQL = "SELECT Count(ID) as Result FROM ccVisits;";
using (var csData = new CsModel(cp.core)) {
csData.openSql(SQL);
if (csData.ok())
{
PagesTotal = csData.getInteger("Result");
}
}
tableBody += AdminUIController.getEditRowLegacy(cp.core, SpanClassAdminNormal + PagesTotal, "Visits Found", "", false, false, "");
//
// ----- Oldest Visit
//
Copy = "unknown";
AgeInDays = "unknown";
using (var csData = new CsModel(cp.core)) {
SQL = cp.core.db.getSQLSelect("ccVisits", "DateAdded", "", "ID", "", 1);
csData.openSql(SQL);
if (csData.ok())
{
DateValue = csData.getDate("DateAdded");
if (DateValue != DateTime.MinValue)
{
Copy = GenericController.encodeText(DateValue);
AgeInDays = GenericController.encodeText(encodeInteger(Math.Floor(encodeNumber(cp.core.doc.profileStartTime - DateValue))));
}
}
}
tableBody += (AdminUIController.getEditRowLegacy(cp.core, SpanClassAdminNormal + Copy + " (" + AgeInDays + " days)", "Oldest Visit", "", false, false, ""));
//
// ----- Viewings Found
//
PagesTotal = 0;
SQL = "SELECT Count(ID) as result FROM ccViewings;";
using (var csData = new CsModel(cp.core)) {
csData.openSql(SQL);
if (csData.ok())
{
PagesTotal = csData.getInteger("Result");
}
csData.close();
}
tableBody += (AdminUIController.getEditRowLegacy(cp.core, SpanClassAdminNormal + PagesTotal, "Viewings Found", "", false, false, ""));
//
tableBody += (HtmlController.tableRowStart() + "<td colspan=\"3\" class=\"ccPanel3D ccAdminEditSubHeader\"><b>Options</b>" + tableCellEnd + kmaEndTableRow);
//
Caption = "Archive Age";
Copy = HtmlController.inputText_Legacy(cp.core, "ArchiveRecordAgeDays", ArchiveRecordAgeDays.ToString(), -1, 20) + " Number of days to keep visit records. 0 disables housekeeping.";
tableBody += (AdminUIController.getEditRowLegacy(cp.core, Copy, Caption));
//
Caption = "Housekeeping Time";
Copy = HtmlController.inputText_Legacy(cp.core, "ArchiveTimeOfDay", ArchiveTimeOfDay, -1, 20) + " The time of day when record deleting should start.";
tableBody += (AdminUIController.getEditRowLegacy(cp.core, Copy, Caption));
//
Caption = "Purge Content Files";
Copy = HtmlController.checkbox("ArchiveAllowFileClean", ArchiveAllowFileClean) + " Delete Contensive content files with no associated database record.";
tableBody += (AdminUIController.getEditRowLegacy(cp.core, Copy, Caption));
//
Content.add(AdminUIController.editTable(tableBody));
Content.add(HtmlController.inputHidden(rnAdminSourceForm, AdminformHousekeepingControl));
ButtonList = ButtonCancel + ",Refresh," + ButtonSave + "," + ButtonOK;
}
//
Caption = "Data Housekeeping Control";
Description = "This tool is used to control the database record housekeeping process. This process deletes visit history records, so care should be taken before making any changes.";
tempGetForm_HouseKeepingControl = AdminUIController.getToolBody(cp.core, Caption, ButtonList, "", false, false, Description, "", 0, Content.text);
//
cp.core.html.addTitle(Caption);
} catch (Exception ex) {
LogController.logError(cp.core, ex);
}
return(tempGetForm_HouseKeepingControl);
}
//
//====================================================================================================
//
// Creates the child page list used by PageContent
//
// RequestedListName is the name of the ChildList (ActiveContent Child Page List)
// ----- New
// {CHILDPAGELIST} = the listname for the orphan list at the bottom of all page content, same as "", "ORPHAN", "NONE"
// RequestedListName = "", same as "ORPHAN", same as "NONE"
// prints orphan list (child pages that have not printed so far (orphan list))
// AllowChildListDisplay - if false, no Child Page List is displayed, but authoring tags are still there
// Changed to friend, not public
// ----- Old
// "NONE" returns child pages with no RequestedListName
// "" same as "NONE"
// "ORPHAN" returns all child pages that have not been printed on this page
// - uses ChildPageListTracking to track what has been seen
//=============================================================================
//
public static string getChildPageList(CoreController core, string requestedListName, string contentName, int parentPageID, bool allowChildListDisplay, bool ArchivePages = false)
{
try {
if (string.IsNullOrEmpty(contentName))
{
contentName = PageContentModel.tableMetadata.contentName;
}
string UcaseRequestedListName = toUCase(requestedListName);
if ((UcaseRequestedListName == "NONE") || (UcaseRequestedListName == "ORPHAN") || (UcaseRequestedListName == "{CHILDPAGELIST}"))
{
UcaseRequestedListName = "";
}
string archiveLink = core.webServer.requestPathPage;
archiveLink = convertLinkToShortLink(archiveLink, core.webServer.requestDomain, core.appConfig.cdnFileUrl);
archiveLink = encodeVirtualPath(archiveLink, core.appConfig.cdnFileUrl, appRootPath, core.webServer.requestDomain);
string sqlCriteria = "(parentId=" + parentPageID + ")" + ((string.IsNullOrWhiteSpace(UcaseRequestedListName)) ? "" : "and(parentListName=" + DbController.encodeSQLText(UcaseRequestedListName) + ")");
List <PageContentModel> childPageList = DbBaseModel.createList <PageContentModel>(core.cpParent, sqlCriteria, "sortOrder");
var inactiveList = new StringBuilder();
var activeList = new StringBuilder();
bool isAuthoring = core.session.isEditing(contentName);
int ChildListCount = 0;
if (childPageList.Count > 0)
{
string currentPageChildPageIdList = core.cpParent.Doc.GetText("Current Page Child PageId List", "0");
string testPageIdList = "," + currentPageChildPageIdList + ",";
foreach (PageContentModel childPage in childPageList)
{
if (!testPageIdList.Contains("," + childPage.id + ","))
{
currentPageChildPageIdList += "," + childPage.id;
}
string PageLink = PageContentController.getPageLink(core, childPage.id, "", true, false);
string pageMenuHeadline = childPage.menuHeadline;
if (string.IsNullOrEmpty(pageMenuHeadline))
{
pageMenuHeadline = childPage.name.Trim(' ');
if (string.IsNullOrEmpty(pageMenuHeadline))
{
pageMenuHeadline = "Related Page";
}
}
string pageEditLink = "";
if (core.session.isEditing(contentName))
{
pageEditLink = AdminUIController.getRecordEditAndCutAnchorTag(core, contentName, childPage.id, true, childPage.name);
}
//
string link = PageLink;
if (ArchivePages)
{
link = GenericController.modifyLinkQuery(archiveLink, rnPageId, encodeText(childPage.id), true);
}
bool blockContentComposite = false;
if (childPage.blockContent || childPage.blockPage)
{
blockContentComposite = !PageContentController.allowThroughPageBlock(core, childPage.id);
}
string LinkedText = GenericController.getLinkedText("<a href=\"" + HtmlController.encodeHtml(link) + "\">", pageMenuHeadline);
if ((string.IsNullOrEmpty(UcaseRequestedListName)) && (childPage.parentListName != "") && (!isAuthoring))
{
//
// ----- Requested orphan list, and this record is in a named list, and not editing, do not display
//
}
else if ((string.IsNullOrEmpty(UcaseRequestedListName)) && (childPage.parentListName != ""))
{
//
// -- child page has a parentListName but this request does not
if (!core.doc.pageController.childPageIdsListed.Contains(childPage.id))
{
//
// -- child page has not yet displays, if editing show it as an orphan page
if (isAuthoring)
{
inactiveList.Append("\r<li name=\"page" + childPage.id + "\" name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItemNoBullet\">");
inactiveList.Append(pageEditLink);
inactiveList.Append("[from missing child page list '" + childPage.parentListName + "': " + LinkedText + "]");
inactiveList.Append("</li>");
}
}
}
else if ((string.IsNullOrEmpty(UcaseRequestedListName)) && (!allowChildListDisplay) && (!isAuthoring))
{
//
// ----- Requested orphan List, Not AllowChildListDisplay, not Authoring, do not display
//
}
else if ((!string.IsNullOrEmpty(UcaseRequestedListName)) && (UcaseRequestedListName != GenericController.toUCase(childPage.parentListName)))
{
//
// ----- requested named list and wrong RequestedListName, do not display
//
}
else if (!childPage.allowInChildLists)
{
//
// ----- Allow in Child Page Lists is false, display hint to authors
//
if (isAuthoring)
{
inactiveList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItemNoBullet\">");
inactiveList.Append(pageEditLink);
inactiveList.Append("[Hidden (Allow in Child Lists is not checked): " + LinkedText + "]");
inactiveList.Append("</li>");
}
}
else if (!childPage.active)
{
//
// ----- Not active record, display hint if authoring
//
if (isAuthoring)
{
inactiveList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItemNoBullet\">");
inactiveList.Append(pageEditLink);
inactiveList.Append("[Hidden (Inactive): " + LinkedText + "]");
inactiveList.Append("</li>");
}
}
else if ((childPage.pubDate != DateTime.MinValue) && (childPage.pubDate > core.doc.profileStartTime))
{
//
// ----- Child page has not been published
//
if (isAuthoring)
{
inactiveList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItemNoBullet\">");
inactiveList.Append(pageEditLink);
inactiveList.Append("[Hidden (To be published " + childPage.pubDate + "): " + LinkedText + "]");
inactiveList.Append("</li>");
}
}
else if ((childPage.dateExpires != DateTime.MinValue) && (childPage.dateExpires < core.doc.profileStartTime))
{
//
// ----- Child page has expired
//
if (isAuthoring)
{
inactiveList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItemNoBullet\">");
inactiveList.Append(pageEditLink);
inactiveList.Append("[Hidden (Expired " + childPage.dateExpires + "): " + LinkedText + "]");
inactiveList.Append("</li>");
}
}
else
{
//
// ----- display list (and authoring links)
//
if (isAuthoring)
{
activeList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccEditWrapper ccListItem allowSort\">");
if (!string.IsNullOrEmpty(pageEditLink))
{
activeList.Append(HtmlController.div(iconGrip, "ccListItemDragHandle") + pageEditLink + " ");
}
activeList.Append(LinkedText);
//
// include authoring mark for content block
//
if (childPage.blockContent)
{
activeList.Append(" [Content Blocked]");
}
if (childPage.blockPage)
{
activeList.Append(" [Page Blocked]");
}
}
else
{
activeList.Append("\r<li name=\"page" + childPage.id + "\" id=\"page" + childPage.id + "\" class=\"ccListItem allowSort\">");
activeList.Append(LinkedText);
}
//
// include overview
// if AllowBrief is false, BriefFilename is not loaded
//
if ((childPage.briefFilename != "") && (childPage.allowBrief))
{
string Brief = encodeText(core.cdnFiles.readFileText(childPage.briefFilename)).Trim(' ');
if (!string.IsNullOrEmpty(Brief))
{
activeList.Append("<div class=\"ccListCopy\">" + Brief + "</div>");
}
}
activeList.Append("</li>");
//
// -- add child page to childPagesListed list
if (!core.doc.pageController.childPageIdsListed.Contains(childPage.id))
{
core.doc.pageController.childPageIdsListed.Add(childPage.id);
}
ChildListCount = ChildListCount + 1;
}
}
if (!string.IsNullOrWhiteSpace(currentPageChildPageIdList))
{
core.cpParent.Doc.SetProperty("Current Page Child PageId List", currentPageChildPageIdList);
}
}
//
// ----- Add Link
//
if (!ArchivePages && isAuthoring)
{
foreach (var AddLink in AdminUIController.getRecordAddAnchorTag(core, contentName, "parentid=" + parentPageID + ",ParentListName=" + UcaseRequestedListName, true))
{
if (!string.IsNullOrEmpty(AddLink))
{
inactiveList.Append("\r<li class=\"ccEditWrapper ccListItemNoBullet\">" + AddLink + "</LI>");
}
}
}
//
// ----- If there is a list, add the list start and list end
//
string result = activeList.ToString() + inactiveList.ToString();
if (!string.IsNullOrEmpty(result))
{
result = "\r<ul id=\"childPageList_" + parentPageID + "_" + requestedListName + "\" class=\"ccChildList\">" + result + "\r</ul>";
}
if ((!string.IsNullOrEmpty(UcaseRequestedListName)) && (ChildListCount == 0) && isAuthoring)
{
result = "[Child Page List with no pages]</p><p>" + result;
}
return(result);
} catch (Exception ex) {
LogController.logError(core, ex);
return(string.Empty);
}
}
//
//====================================================================================================
//
public override string GetEditWrapper(string innerHtml)
{
return(AdminUIController.getEditWrapper(cp.core, innerHtml));
}
//
//===========================================================================
//
public static string get(CoreController core, AdminDataModel adminData, IndexConfigClass indexConfig, PermissionController.UserContentPermissions userContentPermissions, string sql, DataSourceModel dataSource, Dictionary <string, bool> FieldUsedInColumns, Dictionary <string, bool> IsLookupFieldValid)
{
try {
bool allowDelete = (adminData.adminContent.allowDelete) && (userContentPermissions.allowDelete) && (indexConfig.allowDelete);
var DataTable_HdrRow = new StringBuilder("<tr>");
//
// Row Number Column
DataTable_HdrRow.Append("<td width=20 align=center valign=bottom class=\"small ccAdminListCaption\">Row</td>");
//
// Edit Column
DataTable_HdrRow.Append("<td width=20 align=center valign=bottom class=\"small ccAdminListCaption\">Edit</td>");
//
// Delete Select Box Columns
if (!allowDelete)
{
DataTable_HdrRow.Append("<td width=20 align=center valign=bottom class=\"small ccAdminListCaption\"><input TYPE=CheckBox disabled=\"disabled\"></td>");
}
else
{
DataTable_HdrRow.Append("<td width=20 align=center valign=bottom class=\"small ccAdminListCaption\"><input TYPE=CheckBox OnClick=\"CheckInputs('DelCheck',this.checked);\"></td>");
}
//
// -- create header
int ColumnWidthTotal = 0;
foreach (var column in indexConfig.columns)
{
if (column.Width < 1)
{
column.Width = 1;
}
ColumnWidthTotal += column.Width;
}
foreach (var column in indexConfig.columns)
{
//
// ----- print column headers - anchored so they sort columns
//
int ColumnWidth = encodeInteger((100 * column.Width) / (double)ColumnWidthTotal);
//
// if this is a current sort ,add the reverse flag
//
StringBuilder buttonHref = new StringBuilder();
buttonHref.Append("/" + core.appConfig.adminRoute + "?" + rnAdminForm + "=" + AdminFormIndex + "&SetSortField=" + column.Name + "&RT=0&" + RequestNameTitleExtension + "=" + GenericController.encodeRequestVariable(adminData.titleExtension) + "&cid=" + adminData.adminContent.id + "&ad=" + adminData.ignore_legacyMenuDepth);
if (!indexConfig.sorts.ContainsKey(column.Name))
{
buttonHref.Append("&SetSortDirection=1");
}
else
{
switch (indexConfig.sorts[column.Name].direction)
{
case 1: {
buttonHref.Append("&SetSortDirection=2");
break;
}
case 2: {
buttonHref.Append("&SetSortDirection=0");
break;
}
default: {
// nothing
break;
}
}
}
//
// -- column header includes WherePairCount
if (!adminData.wherePair.Count.Equals(0))
{
int ptr = 0;
foreach (var kvp in adminData.wherePair)
{
if (!string.IsNullOrWhiteSpace(kvp.Key))
{
buttonHref.Append("&wl" + ptr + "=" + GenericController.encodeRequestVariable(kvp.Value));
buttonHref.Append("&wr" + ptr + "=" + GenericController.encodeRequestVariable(kvp.Value));
ptr++;
}
}
}
string buttonFace = adminData.adminContent.fields[column.Name.ToLowerInvariant()].caption;
buttonFace = GenericController.strReplace(buttonFace, " ", " ");
string SortTitle = "Sort A-Z";
//
if (indexConfig.sorts.ContainsKey(column.Name))
{
string sortSuffix = ((indexConfig.sorts.Count < 2) ? "" : indexConfig.sorts[column.Name].order.ToString());
switch (indexConfig.sorts[column.Name].direction)
{
case 1: {
buttonFace = iconArrowDown + sortSuffix + " " + buttonFace;
SortTitle = "Sort Z-A";
break;
}
case 2: {
buttonFace = iconArrowUp + sortSuffix + " " + buttonFace;
SortTitle = "Remove Sort";
break;
}
default: {
// nothing
break;
}
}
}
if (indexConfig.allowColumnSort)
{
buttonFace = HtmlController.a(buttonFace, new CPBase.BaseModels.HtmlAttributesA()
{
title = SortTitle,
href = buttonHref.ToString(),
@class = "ccAdminListCaption"
});
}
adminData.buttonObjectCount += 1;
DataTable_HdrRow.Append("<td width=\"" + ColumnWidth + "%\" valign=bottom align=left class=\"small ccAdminListCaption\">");
DataTable_HdrRow.Append(buttonFace);
DataTable_HdrRow.Append("</td>");
}
DataTable_HdrRow.Append("</tr>");
//
// -- generic admin url for edit and add links
string adminEditPresetArgQsList = "";
string adminUrlBase = "\\" + core.appConfig.adminRoute + "?" + rnAdminAction + "=" + Constants.AdminActionNop + "&cid=" + adminData.adminContent.id + "&" + RequestNameTitleExtension + "=" + GenericController.encodeRequestVariable(adminData.titleExtension) + "&ad=" + adminData.ignore_legacyMenuDepth + "&" + rnAdminSourceForm + "=" + adminData.adminForm + "&" + rnAdminForm + "=" + AdminFormEdit;
if (!adminData.wherePair.Count.Equals(0))
{
int WhereCount = 0;
foreach (var kvp in adminData.wherePair)
{
adminEditPresetArgQsList += "&" + encodeRequestVariable(kvp.Key) + "=" + GenericController.encodeRequestVariable(kvp.Value);
WhereCount++;
}
adminUrlBase += adminEditPresetArgQsList;
}
//
// -- output data rows
var dataTableRows = new StringBuilder();
string rowColor = "";
int rowNumber = 0;
int rowNumberLast = 0;
using (var csData = new CsModel(core)) {
if (csData.openSql(sql, dataSource.name, indexConfig.recordsPerPage, indexConfig.pageNumber))
{
rowNumber = indexConfig.recordTop;
rowNumberLast = indexConfig.recordTop + indexConfig.recordsPerPage;
//
// --- Print out the records
while ((csData.ok()) && (rowNumber < rowNumberLast))
{
int recordId = csData.getInteger("ID");
if (rowColor == "class=\"ccAdminListRowOdd\"")
{
rowColor = "class=\"ccAdminListRowEven\"";
}
else
{
rowColor = "class=\"ccAdminListRowOdd\"";
}
//
// -- new row
dataTableRows.Append(Environment.NewLine + "<tr>");
//
// --- row number column
dataTableRows.Append("<td align=right " + rowColor + ">" + (rowNumber + 1).ToString() + "</td>");
//
// --- edit column
dataTableRows.Append("<td align=center " + rowColor + ">" + getRecordEditAnchorTag(adminUrlBase + "&id=" + recordId) + "</td>");
//
// --- Delete Checkbox Columns
if (allowDelete)
{
dataTableRows.Append("<td align=center " + rowColor + "><input TYPE=CheckBox NAME=row" + rowNumber + " VALUE=1 ID=\"DelCheck\"><input type=hidden name=rowid" + rowNumber + " VALUE=" + recordId + "></span></td>");
}
else
{
dataTableRows.Append("<td align=center " + rowColor + "><input TYPE=CheckBox disabled=\"disabled\" NAME=row" + rowNumber + " VALUE=1><input type=hidden name=rowid" + rowNumber + " VALUE=" + recordId + "></span></td>");
}
//
// --- field columns
foreach (var column in indexConfig.columns)
{
string columnNameLc = column.Name.ToLowerInvariant();
if (FieldUsedInColumns.ContainsKey(columnNameLc))
{
if (FieldUsedInColumns[columnNameLc])
{
dataTableRows.Append((Environment.NewLine + "<td valign=\"middle\" " + rowColor + " align=\"left\">" + SpanClassAdminNormal));
dataTableRows.Append(getGridCell(core, adminData, column.Name, csData, IsLookupFieldValid[columnNameLc], GenericController.toLCase(adminData.adminContent.tableName) == "ccemail"));
dataTableRows.Append((" </span></td>"));
}
}
}
dataTableRows.Append(("\n </tr>"));
csData.goNext();
rowNumber = rowNumber + 1;
}
dataTableRows.Append("<input type=hidden name=rowcnt value=" + rowNumber + ">");
//
// --- print out the stuff at the bottom
//
int RecordTop_NextPage = indexConfig.recordTop;
if (csData.ok())
{
RecordTop_NextPage = rowNumber;
}
int RecordTop_PreviousPage = indexConfig.recordTop - indexConfig.recordsPerPage;
if (RecordTop_PreviousPage < 0)
{
RecordTop_PreviousPage = 0;
}
}
}
//
// Header at bottom
//
if (rowColor == "class=\"ccAdminListRowOdd\"")
{
rowColor = "class=\"ccAdminListRowEven\"";
}
else
{
rowColor = "class=\"ccAdminListRowOdd\"";
}
string blankRow = "<tr><td colspan=" + (indexConfig.columns.Count + 3) + " " + rowColor + " style=\"text-align:left ! important;\">{msg}</td></tr>";
if (rowNumber == 0)
{
//
// -- No records found
dataTableRows.Append(blankRow.Replace("{msg}", "----- no records were found -----"));
}
else
{
if (rowNumber < rowNumberLast)
{
//
// --End of list
dataTableRows.Append(blankRow.Replace("{msg}", "----- end of list -----"));
}
}
if (indexConfig.allowAddRow)
{
//
// optional AddRow
foreach (var addTag in getRecordAddAnchorTag(core, adminData.adminContent.name, adminEditPresetArgQsList, false, userContentPermissions.allowAdd))
{
dataTableRows.Append(blankRow.Replace("{msg}", addTag));
}
}
//
// Add another header to the data rows
//
dataTableRows.Append(DataTable_HdrRow.ToString());
//
var DataTable_FindRow = new StringBuilder();
if (indexConfig.allowFind)
{
//
// ----- DataTable_FindRow
//
DataTable_FindRow.Append("<tr><td colspan=" + (3 + indexConfig.columns.Count) + " style=\"background-color:black;height:1;\"></td></tr>");
DataTable_FindRow.Append("<tr>");
DataTable_FindRow.Append("<td valign=\"middle\" colspan=3 width=\"60\" class=\"ccPanel\" align=center style=\"vertical-align:middle;padding:8px;text-align:center ! important;\">");
DataTable_FindRow.Append(AdminUIController.getButtonPrimary(ButtonFind, "", false, "FindButton") + "</td>");
int ColumnPointer = 0;
var listOfMatches = new List <FindWordMatchEnum> {
FindWordMatchEnum.matchincludes, FindWordMatchEnum.MatchEquals, FindWordMatchEnum.MatchTrue, FindWordMatchEnum.MatchFalse
};
foreach (var column in indexConfig.columns)
{
string FieldName = GenericController.toLCase(column.Name);
string FindWordValue = "";
if (indexConfig.findWords.ContainsKey(FieldName))
{
var findWord = indexConfig.findWords[FieldName];
if (listOfMatches.Any(s => findWord.MatchOption.Equals(s)))
{
FindWordValue = findWord.Value;
}
}
DataTable_FindRow.Append(Environment.NewLine + "<td valign=\"middle\" align=\"center\" class=\"ccPanel3DReverse\" style=\"padding:8px;\">"
+ "<input type=hidden name=\"FindName" + ColumnPointer + "\" value=\"" + FieldName + "\">"
+ "<input class=\"form-control findInput\" onkeypress=\"KeyCheck(event);\" type=text id=\"F" + ColumnPointer + "\" name=\"FindValue" + ColumnPointer + "\" value=\"" + FindWordValue + "\" style=\"padding-right:.2rem;padding-left:.2rem;\">"
+ "</td>");
ColumnPointer += 1;
}
DataTable_FindRow.Append("</tr>");
}
//
// Assemble DataTable
//
string grid = ""
+ "<table ID=\"DataTable\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\" width=\"100%\" style=\"Background-Color:white;\">"
+ DataTable_HdrRow + dataTableRows + DataTable_FindRow + "</table>";
return(grid);
} catch (Exception ex) {
LogController.logError(core, ex);
return(HtmlController.div("There was an error creating the record list."));
}
}
//
//====================================================================================================
//
public override string GetEditWrapper(string innerHtml, string contentName, int recordId)
{
return(AdminUIController.getEditWrapper(cp.core, innerHtml, contentName, recordId));
}
//
//=================================================================================
//
//=================================================================================
//
public static string get(CPClass cp, CoreController core, AdminDataModel adminData)
{
string returnForm = "";
try {
//
string SearchValue = null;
FindWordMatchEnum MatchOption = 0;
int FormFieldPtr = 0;
int FormFieldCnt = 0;
ContentMetadataModel CDef = null;
string FieldName = null;
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
int FieldPtr = 0;
bool RowEven = false;
string RQS = null;
string[] FieldNames = { };
string[] FieldCaption = { };
int[] fieldId = null;
CPContentBaseClass.FieldTypeIdEnum[] fieldTypeId = { };
string[] FieldValue = { };
int[] FieldMatchOptions = { };
int FieldMatchOption = 0;
string[] FieldLookupContentName = { };
string[] FieldLookupList = { };
int ContentId = 0;
int FieldCnt = 0;
int FieldSize = 0;
int RowPointer = 0;
string LeftButtons = "";
string ButtonBar = null;
string Title = null;
string TitleBar = null;
string Content = null;
//
// Process last form
//
string Button = core.docProperties.getText("button");
IndexConfigClass IndexConfig = null;
if (!string.IsNullOrEmpty(Button))
{
switch (Button)
{
case ButtonSearch:
IndexConfig = IndexConfigClass.get(core, adminData);
FormFieldCnt = core.docProperties.getInteger("fieldcnt");
if (FormFieldCnt > 0)
{
for (FormFieldPtr = 0; FormFieldPtr < FormFieldCnt; FormFieldPtr++)
{
FieldName = GenericController.toLCase(core.docProperties.getText("fieldname" + FormFieldPtr));
MatchOption = (FindWordMatchEnum)core.docProperties.getInteger("FieldMatch" + FormFieldPtr);
switch (MatchOption)
{
case FindWordMatchEnum.MatchEquals:
case FindWordMatchEnum.MatchGreaterThan:
case FindWordMatchEnum.matchincludes:
case FindWordMatchEnum.MatchLessThan:
SearchValue = core.docProperties.getText("FieldValue" + FormFieldPtr);
break;
default:
SearchValue = "";
break;
}
if (!IndexConfig.findWords.ContainsKey(FieldName))
{
//
// fieldname not found, save if not FindWordMatchEnum.MatchIgnore
//
if (MatchOption != FindWordMatchEnum.MatchIgnore)
{
IndexConfig.findWords.Add(FieldName, new IndexConfigFindWordClass {
Name = FieldName,
MatchOption = MatchOption,
Value = SearchValue
});
}
}
else
{
//
// fieldname was found
//
IndexConfig.findWords[FieldName].MatchOption = MatchOption;
IndexConfig.findWords[FieldName].Value = SearchValue;
}
}
}
GetHtmlBodyClass.setIndexSQL_SaveIndexConfig(cp, core, IndexConfig);
return(string.Empty);
case ButtonCancel:
return(string.Empty);
}
}
IndexConfig = IndexConfigClass.get(core, adminData);
Button = "CriteriaSelect";
RQS = core.doc.refreshQueryString;
//
// ----- ButtonBar
//
if (adminData.ignore_legacyMenuDepth > 0)
{
LeftButtons += AdminUIController.getButtonPrimary(ButtonClose, "window.close();");
}
else
{
LeftButtons += AdminUIController.getButtonPrimary(ButtonCancel);
}
LeftButtons += AdminUIController.getButtonPrimary(ButtonSearch);
ButtonBar = AdminUIController.getSectionButtonBar(core, LeftButtons, "");
//
// ----- TitleBar
//
Title = adminData.adminContent.name;
Title = Title + " Advanced Search";
string TitleDescription = "<div>Enter criteria for each field to identify and select your results. The results of a search will have to have all of the criteria you enter.</div>";
TitleBar = AdminUIController.getSectionHeader(core, Title, TitleDescription);
//
// ----- List out all fields
//
CDef = ContentMetadataModel.createByUniqueName(core, adminData.adminContent.name);
FieldSize = 100;
Array.Resize(ref FieldNames, FieldSize + 1);
Array.Resize(ref FieldCaption, FieldSize + 1);
Array.Resize(ref fieldId, FieldSize + 1);
Array.Resize(ref fieldTypeId, FieldSize + 1);
Array.Resize(ref FieldValue, FieldSize + 1);
Array.Resize(ref FieldMatchOptions, FieldSize + 1);
Array.Resize(ref FieldLookupContentName, FieldSize + 1);
Array.Resize(ref FieldLookupList, FieldSize + 1);
foreach (KeyValuePair <string, ContentFieldMetadataModel> keyValuePair in adminData.adminContent.fields)
{
ContentFieldMetadataModel field = keyValuePair.Value;
if (FieldPtr >= FieldSize)
{
FieldSize = FieldSize + 100;
Array.Resize(ref FieldNames, FieldSize + 1);
Array.Resize(ref FieldCaption, FieldSize + 1);
Array.Resize(ref fieldId, FieldSize + 1);
Array.Resize(ref fieldTypeId, FieldSize + 1);
Array.Resize(ref FieldValue, FieldSize + 1);
Array.Resize(ref FieldMatchOptions, FieldSize + 1);
Array.Resize(ref FieldLookupContentName, FieldSize + 1);
Array.Resize(ref FieldLookupList, FieldSize + 1);
}
FieldName = GenericController.toLCase(field.nameLc);
FieldNames[FieldPtr] = FieldName;
FieldCaption[FieldPtr] = field.caption;
fieldId[FieldPtr] = field.id;
fieldTypeId[FieldPtr] = field.fieldTypeId;
if (fieldTypeId[FieldPtr] == CPContentBaseClass.FieldTypeIdEnum.Lookup)
{
ContentId = field.lookupContentId;
if (ContentId > 0)
{
FieldLookupContentName[FieldPtr] = MetadataController.getContentNameByID(core, ContentId);
}
FieldLookupList[FieldPtr] = field.lookupList;
}
//
// set prepoplate value from indexconfig
//
if (IndexConfig.findWords.ContainsKey(FieldName))
{
FieldValue[FieldPtr] = IndexConfig.findWords[FieldName].Value;
FieldMatchOptions[FieldPtr] = (int)IndexConfig.findWords[FieldName].MatchOption;
}
FieldPtr += 1;
}
FieldCnt = FieldPtr;
//
// Add headers to stream
//
returnForm = returnForm + "<table border=0 width=100% cellspacing=0 cellpadding=4>";
//
RowPointer = 0;
for (FieldPtr = 0; FieldPtr < FieldCnt; FieldPtr++)
{
returnForm = returnForm + HtmlController.inputHidden("fieldname" + FieldPtr, FieldNames[FieldPtr]);
RowEven = ((RowPointer % 2) == 0);
FieldMatchOption = FieldMatchOptions[FieldPtr];
switch (fieldTypeId[FieldPtr])
{
case CPContentBaseClass.FieldTypeIdEnum.Date:
//
// Date
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchEmpty).ToString(), FieldMatchOption.ToString(), "") + "empty</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchNotEmpty).ToString(), FieldMatchOption.ToString(), "") + "not empty</div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchEquals).ToString(), FieldMatchOption.ToString(), "") + "=</div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchGreaterThan).ToString(), FieldMatchOption.ToString(), "") + "></div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, encodeInteger(FindWordMatchEnum.MatchLessThan).ToString(), FieldMatchOption.ToString(), "") + "<</div>"
+ "<div style=\"display:block;float:left;width:300px;\">" + HtmlController.inputDate(core, "fieldvalue" + FieldPtr, encodeDate(FieldValue[FieldPtr])).Replace(">", " onFocus=\"ccAdvSearchText\">") + "</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
break;
case CPContentBaseClass.FieldTypeIdEnum.Currency:
case CPContentBaseClass.FieldTypeIdEnum.Float:
case CPContentBaseClass.FieldTypeIdEnum.Integer:
case CPContentBaseClass.FieldTypeIdEnum.AutoIdIncrement:
//
// -- Numeric - changed FindWordMatchEnum.MatchEquals to MatchInclude to be compatible with Find Search
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchEmpty).ToString(), FieldMatchOption.ToString(), "") + "empty</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchNotEmpty).ToString(), FieldMatchOption.ToString(), "") + "not empty</div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.matchincludes).ToString(), FieldMatchOption.ToString(), "n" + FieldPtr) + "=</div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchGreaterThan).ToString(), FieldMatchOption.ToString(), "") + "></div>"
+ "<div style=\"display:block;float:left;width:50px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchLessThan).ToString(), FieldMatchOption.ToString(), "") + "<</div>"
+ "<div style=\"display:block;float:left;width:300px;\">" + HtmlController.inputText_Legacy(core, "fieldvalue" + FieldPtr, FieldValue[FieldPtr], 1, 5, "", false, false, "ccAdvSearchText").Replace(">", " onFocus=\"var e=getElementById('n" + FieldPtr + "');e.checked=1;\">") + "</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
RowPointer += 1;
break;
case CPContentBaseClass.FieldTypeIdEnum.File:
case CPContentBaseClass.FieldTypeIdEnum.FileImage:
//
// File
//
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchEmpty).ToString(), FieldMatchOption.ToString(), "") + "empty</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchNotEmpty).ToString(), FieldMatchOption.ToString(), "") + "not empty</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
RowPointer = RowPointer + 1;
break;
case CPContentBaseClass.FieldTypeIdEnum.Boolean:
//
// Boolean
//
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchTrue).ToString(), FieldMatchOption.ToString(), "") + "true</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchFalse).ToString(), FieldMatchOption.ToString(), "") + "false</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
break;
case CPContentBaseClass.FieldTypeIdEnum.Text:
case CPContentBaseClass.FieldTypeIdEnum.LongText:
case CPContentBaseClass.FieldTypeIdEnum.HTML:
case CPContentBaseClass.FieldTypeIdEnum.HTMLCode:
case CPContentBaseClass.FieldTypeIdEnum.FileHTML:
case CPContentBaseClass.FieldTypeIdEnum.FileHTMLCode:
case CPContentBaseClass.FieldTypeIdEnum.FileCSS:
case CPContentBaseClass.FieldTypeIdEnum.FileJavascript:
case CPContentBaseClass.FieldTypeIdEnum.FileXML:
//
// Text
//
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchEmpty).ToString(), FieldMatchOption.ToString(), "") + "empty</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchNotEmpty).ToString(), FieldMatchOption.ToString(), "") + "not empty</div>"
+ "<div style=\"display:block;float:left;width:150px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.matchincludes).ToString(), FieldMatchOption.ToString(), "t" + FieldPtr) + "includes</div>"
+ "<div style=\"display:block;float:left;width:300px;\">" + HtmlController.inputText_Legacy(core, "fieldvalue" + FieldPtr, FieldValue[FieldPtr], 1, 5, "", false, false, "ccAdvSearchText").Replace(">", " onFocus=\"var e=getElementById('t" + FieldPtr + "');e.checked=1;\">") + "</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
RowPointer = RowPointer + 1;
break;
case CPContentBaseClass.FieldTypeIdEnum.Lookup:
case CPContentBaseClass.FieldTypeIdEnum.MemberSelect:
//
// Lookup
returnForm = returnForm + "<tr>"
+ "<td class=\"ccAdminEditCaption\">" + FieldCaption[FieldPtr] + "</td>"
+ "<td class=\"ccAdminEditField\">"
+ "<div style=\"display:block;float:left;width:800px;\">"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchIgnore).ToString(), FieldMatchOption.ToString(), "") + "ignore</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchEmpty).ToString(), FieldMatchOption.ToString(), "") + "empty</div>"
+ "<div style=\"display:block;float:left;width:100px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.MatchNotEmpty).ToString(), FieldMatchOption.ToString(), "") + "not empty</div>"
+ "<div style=\"display:block;float:left;width:150px;\">" + HtmlController.inputRadio("FieldMatch" + FieldPtr, ((int)FindWordMatchEnum.matchincludes).ToString(), FieldMatchOption.ToString(), "t" + FieldPtr) + "includes</div>"
+ "<div style=\"display:block;float:left;width:300px;\">" + HtmlController.inputText_Legacy(core, "fieldvalue" + FieldPtr, FieldValue[FieldPtr], 1, 5, "", false, false, "ccAdvSearchText").Replace(">", " onFocus=\"var e=getElementById('t" + FieldPtr + "'); e.checked= 1;\">") + "</div>"
+ "</div>"
+ "</td>"
+ "</tr>";
RowPointer = RowPointer + 1;
break;
}
}
returnForm = returnForm + HtmlController.tableRowStart();
returnForm = returnForm + HtmlController.tableCellStart("120", 1, RowEven, "right") + "<img src=" + cdnPrefix + "images/spacer.gif width=120 height=1></td>";
returnForm = returnForm + HtmlController.tableCellStart("99%", 1, RowEven, "left") + "<img src=" + cdnPrefix + "images/spacer.gif width=1 height=1></td>";
returnForm = returnForm + kmaEndTableRow;
returnForm = returnForm + "</table>";
Content = returnForm;
//
// Assemble LiveWindowTable
Stream.add(ButtonBar);
Stream.add(TitleBar);
Stream.add(Content);
Stream.add(ButtonBar);
Stream.add("<input type=hidden name=fieldcnt VALUE=" + FieldCnt + ">");
Stream.add("<input type=hidden name=" + RequestNameAdminSubForm + " VALUE=" + AdminFormIndex_SubFormAdvancedSearch + ">");
returnForm = HtmlController.form(core, Stream.text);
core.html.addTitle(adminData.adminContent.name + " Advanced Search");
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
}
return(returnForm);
}
//
//=============================================================================
// Create a child content
//=============================================================================
//
private string GetForm_CreateChildContent(CoreController core)
{
string result = "";
try {
int ParentContentId = 0;
string ChildContentName = "";
bool AddAdminMenuEntry = false;
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
string ButtonList = ButtonCancel + "," + ButtonRun;
//
Stream.add(AdminUIController.getHeaderTitleDescription("Create a Child Content from a Content Definition", "This tool creates a Content Definition based on another Content Definition."));
//
// print out the submit form
if (core.docProperties.getText("Button") != "")
{
//
// Process input
//
ParentContentId = core.docProperties.getInteger("ParentContentID");
var parentContentMetadata = ContentMetadataModel.create(core, ParentContentId);
ChildContentName = core.docProperties.getText("ChildContentName");
AddAdminMenuEntry = core.docProperties.getBoolean("AddAdminMenuEntry");
//
Stream.add(SpanClassAdminSmall);
if ((parentContentMetadata == null) || (string.IsNullOrEmpty(ChildContentName)))
{
Stream.add("<p>You must select a parent and provide a child name.</p>");
}
else
{
//
// Create Definition
//
Stream.add("<P>Creating content [" + ChildContentName + "] from [" + parentContentMetadata + "]");
var childContentMetadata = parentContentMetadata.createContentChild(core, ChildContentName, core.session.user.id);
//
Stream.add("<br>Reloading Content Definitions...");
core.cache.invalidateAll();
core.clearMetaData();
Stream.add("<br>Finished</P>");
}
Stream.add("</SPAN>");
}
Stream.add(SpanClassAdminNormal);
//
Stream.add("Parent Content Name<br>");
Stream.add(core.html.selectFromContent("ParentContentID", ParentContentId, "Content", ""));
Stream.add("<br><br>");
//
Stream.add("Child Content Name<br>");
Stream.add(HtmlController.inputText_Legacy(core, "ChildContentName", ChildContentName, 1, 40));
Stream.add("<br><br>");
//
Stream.add("Add Admin Menu Entry under Parent's Menu Entry<br>");
Stream.add(HtmlController.checkbox("AddAdminMenuEntry", AddAdminMenuEntry));
Stream.add("<br><br>");
//
//Stream.Add( core.main_GetFormInputHidden(RequestNameAdminForm, AdminFormToolCreateChildContent)
Stream.add("</SPAN>");
//
result = AdminUIController.getToolForm(core, Stream.text, ButtonList);
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(result);
}
//
//====================================================================================================
/// <summary>
/// Get the Configure Edit
/// </summary>
/// <param name="cp"></param>
/// <returns></returns>
public static string get(CPClass cp)
{
CoreController core = cp.core;
try {
KeyPtrController Index = new KeyPtrController();
int ContentId = cp.Doc.GetInteger(RequestNameToolContentId);
var contentMetadata = ContentMetadataModel.create(core, ContentId, true, true);
int RecordCount = 0;
int formFieldId = 0;
string StatusMessage = "";
string ErrorMessage = "";
bool ReloadCDef = cp.Doc.GetBoolean("ReloadCDef");
if (contentMetadata != null)
{
string ToolButton = cp.Doc.GetText("Button");
//
if (!string.IsNullOrEmpty(ToolButton))
{
bool AllowContentAutoLoad = false;
if (ToolButton != ButtonCancel)
{
//
// Save the form changes
//
AllowContentAutoLoad = cp.Site.GetBoolean("AllowContentAutoLoad", true);
cp.Site.SetProperty("AllowContentAutoLoad", "false");
//
// ----- Save the input
//
RecordCount = GenericController.encodeInteger(cp.Doc.GetInteger("dtfaRecordCount"));
if (RecordCount > 0)
{
int RecordPointer = 0;
for (RecordPointer = 0; RecordPointer < RecordCount; RecordPointer++)
{
//
string formFieldName = cp.Doc.GetText("dtfaName." + RecordPointer);
CPContentBaseClass.FieldTypeIdEnum formFieldTypeId = (CPContentBaseClass.FieldTypeIdEnum)cp.Doc.GetInteger("dtfaType." + RecordPointer);
formFieldId = GenericController.encodeInteger(cp.Doc.GetInteger("dtfaID." + RecordPointer));
bool formFieldInherited = cp.Doc.GetBoolean("dtfaInherited." + RecordPointer);
//
// problem - looking for the name in the Db using the form's name, but it could have changed.
// have to look field up by id
//
foreach (KeyValuePair <string, Processor.Models.Domain.ContentFieldMetadataModel> cdefFieldKvp in contentMetadata.fields)
{
if (cdefFieldKvp.Value.id == formFieldId)
{
//
// Field was found in CDef
//
if (cdefFieldKvp.Value.inherited && (!formFieldInherited))
{
//
// Was inherited, but make a copy of the field
//
using (var CSTarget = new CsModel(core)) {
if (CSTarget.insert("Content Fields"))
{
using (var CSSource = new CsModel(core)) {
if (CSSource.openRecord("Content Fields", formFieldId))
{
CSSource.copyRecord(CSTarget);
}
}
formFieldId = CSTarget.getInteger("ID");
CSTarget.set("ContentID", ContentId);
}
CSTarget.close();
}
ReloadCDef = true;
}
else if ((!cdefFieldKvp.Value.inherited) && (formFieldInherited))
{
//
// Was a field, make it inherit from it's parent
MetadataController.deleteContentRecord(core, "Content Fields", formFieldId);
ReloadCDef = true;
}
else if ((!cdefFieldKvp.Value.inherited) && (!formFieldInherited))
{
//
// not inherited, save the field values and mark for a reload
//
{
if (formFieldName.IndexOf(" ") != -1)
{
//
// remoave spaces from new name
//
StatusMessage = StatusMessage + "<LI>Field [" + formFieldName + "] was renamed [" + GenericController.strReplace(formFieldName, " ", "") + "] because the field name can not include spaces.</LI>";
formFieldName = GenericController.strReplace(formFieldName, " ", "");
}
//
string SQL = null;
//
if ((!string.IsNullOrEmpty(formFieldName)) && ((int)formFieldTypeId != 0) && ((cdefFieldKvp.Value.nameLc == "") || (cdefFieldKvp.Value.fieldTypeId == 0)))
{
//
// Create Db field, Field is good but was not before
//
core.db.createSQLTableField(contentMetadata.tableName, formFieldName, formFieldTypeId);
StatusMessage = StatusMessage + "<LI>Field [" + formFieldName + "] was saved to this content definition and a database field was created in [" + contentMetadata.tableName + "].</LI>";
}
else if ((string.IsNullOrEmpty(formFieldName)) || ((int)formFieldTypeId == 0))
{
//
// name blank or type=0 - do nothing but tell them
//
if (string.IsNullOrEmpty(formFieldName) && ((int)formFieldTypeId == 0))
{
ErrorMessage += "<LI>Field number " + (RecordPointer + 1) + " was saved to this content definition but no database field was created because a name and field type are required.</LI>";
}
else if (formFieldName == "unnamedfield" + formFieldId.ToString())
{
ErrorMessage += "<LI>Field number " + (RecordPointer + 1) + " was saved to this content definition but no database field was created because a field name is required.</LI>";
}
else
{
ErrorMessage += "<LI>Field [" + formFieldName + "] was saved to this content definition but no database field was created because a field type are required.</LI>";
}
}
else if ((formFieldName == cdefFieldKvp.Value.nameLc) && (formFieldTypeId != cdefFieldKvp.Value.fieldTypeId))
{
//
// Field Type changed, must be done manually
//
ErrorMessage += "<LI>Field [" + formFieldName + "] changed type from [" + DbBaseModel.getRecordName <ContentFieldTypeModel>(core.cpParent, (int)cdefFieldKvp.Value.fieldTypeId) + "] to [" + DbBaseModel.getRecordName <ContentFieldTypeModel>(core.cpParent, (int)formFieldTypeId) + "]. This may have caused a problem converting content.</LI>";
int DataSourceTypeId = core.db.getDataSourceType();
switch (DataSourceTypeId)
{
case DataSourceTypeODBCMySQL:
SQL = "alter table " + contentMetadata.tableName + " change " + cdefFieldKvp.Value.nameLc + " " + cdefFieldKvp.Value.nameLc + " " + core.db.getSQLAlterColumnType(formFieldTypeId) + ";";
break;
default:
SQL = "alter table " + contentMetadata.tableName + " alter column " + cdefFieldKvp.Value.nameLc + " " + core.db.getSQLAlterColumnType(formFieldTypeId) + ";";
break;
}
core.db.executeNonQuery(SQL);
}
SQL = "Update ccFields"
+ " Set name=" + DbController.encodeSQLText(formFieldName)
+ ",type=" + (int)formFieldTypeId
+ ",caption=" + DbController.encodeSQLText(cp.Doc.GetText("dtfaCaption." + RecordPointer))
+ ",DefaultValue=" + DbController.encodeSQLText(cp.Doc.GetText("dtfaDefaultValue." + RecordPointer))
+ ",EditSortPriority=" + DbController.encodeSQLText(GenericController.encodeText(cp.Doc.GetInteger("dtfaEditSortPriority." + RecordPointer)))
+ ",Active=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaActive." + RecordPointer))
+ ",ReadOnly=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaReadOnly." + RecordPointer))
+ ",Authorable=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaAuthorable." + RecordPointer))
+ ",Required=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaRequired." + RecordPointer))
+ ",UniqueName=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaUniqueName." + RecordPointer))
+ ",TextBuffered=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaTextBuffered." + RecordPointer))
+ ",Password="******"dtfaPassword." + RecordPointer))
+ ",HTMLContent=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaHTMLContent." + RecordPointer))
+ ",EditTab=" + DbController.encodeSQLText(cp.Doc.GetText("dtfaEditTab." + RecordPointer))
+ ",Scramble=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaScramble." + RecordPointer)) + "";
if (core.session.isAuthenticatedAdmin())
{
SQL += ",adminonly=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaAdminOnly." + RecordPointer));
}
if (core.session.isAuthenticatedDeveloper())
{
SQL += ",DeveloperOnly=" + DbController.encodeSQLBoolean(cp.Doc.GetBoolean("dtfaDeveloperOnly." + RecordPointer));
}
SQL += " where ID=" + formFieldId;
core.db.executeNonQuery(SQL);
ReloadCDef = true;
}
}
break;
}
}
}
}
core.cache.invalidateAll();
core.clearMetaData();
}
if (ToolButton == ButtonAdd)
{
//
// ----- Insert a blank Field
var defaultValues = ContentMetadataModel.getDefaultValueDict(core, ContentFieldModel.tableMetadata.contentName);
var field = ContentFieldModel.addDefault <ContentFieldModel>(core.cpParent, defaultValues);
field.name = "unnamedField" + field.id.ToString();
field.contentId = ContentId;
field.editSortPriority = 0;
field.save(core.cpParent);
ReloadCDef = true;
}
//
// ----- Button Reload CDef
if (ToolButton == ButtonSaveandInvalidateCache)
{
core.cache.invalidateAll();
core.clearMetaData();
}
//
// ----- Restore Content Autoload site property
//
if (AllowContentAutoLoad)
{
cp.Site.SetProperty("AllowContentAutoLoad", AllowContentAutoLoad.ToString());
}
//
// ----- Cancel or Save, reload CDef and go
//
if ((ToolButton == ButtonCancel) || (ToolButton == ButtonOK))
{
//
// ----- Exit back to menu
//
return(core.webServer.redirect(core.appConfig.adminRoute, "Tool-ConfigureContentEdit, ok or cancel button, go to root."));
}
}
}
//
// Print Output
string description = ""
+ HtmlController.p("Use this tool to add or modify content definition fields and the underlying sql table fields.")
+ ((ContentId.Equals(0)) ? "" : ""
+ HtmlController.ul(""
+ HtmlController.li(HtmlController.a("Edit Content", "?aa=0&cid=3&id=" + ContentId + "&tx=&ad=0&asf=1&af=4", "nav-link btn btn-primary"), "nav-item mr-1")
+ HtmlController.li(HtmlController.a("Edit Records", "?cid=" + ContentId, "nav-link btn btn-primary"), "nav-item mr-1")
+ HtmlController.li(HtmlController.a("Select Different Fields", "?af=105", "nav-link btn btn-primary"), "nav-item mr-1")
, "nav")
);
StringBuilderLegacyController Stream = new StringBuilderLegacyController();
Stream.add(AdminUIController.getHeaderTitleDescription("Manage Admin Edit Fields", description));
//
// -- status of last operation
if (!string.IsNullOrEmpty(StatusMessage))
{
Stream.add(AdminUIController.getToolFormRow(core, "<UL>" + StatusMessage + "</UL>"));
}
//
// -- errors with last operations
if (!string.IsNullOrEmpty(ErrorMessage))
{
Stream.add(HtmlController.div("There was a problem saving these changes" + "<UL>" + ErrorMessage + "</UL>", "ccError"));
}
if (ReloadCDef)
{
contentMetadata = Processor.Models.Domain.ContentMetadataModel.create(core, ContentId, true, true);
}
string ButtonList = ButtonCancel + "," + ButtonSelect;
if (ContentId == 0)
{
//
// content tables that have edit forms to Configure
bool isEmptyList = false;
Stream.add(AdminUIController.getToolFormInputRow(core, "Select a Content Definition to Configure", AdminUIEditorController.getLookupContentEditor(core, RequestNameToolContentId, ContentId, ContentMetadataModel.getContentId(core, "Content"), ref isEmptyList, false, "", "", false, "")));
}
else
{
//
// Configure edit form
Stream.add(HtmlController.inputHidden(RequestNameToolContentId, ContentId));
Stream.add(core.html.getPanelTop());
ButtonList = ButtonCancel + "," + ButtonSave + "," + ButtonOK + "," + ButtonAdd;
//
// Get a new copy of the content definition
//
Stream.add(SpanClassAdminNormal + "<P><B>" + contentMetadata.name + "</b></P>");
Stream.add("<table border=\"0\" cellpadding=\"1\" cellspacing=\"1\" width=\"100%\">");
//
int ParentContentId = contentMetadata.parentId;
bool AllowCDefInherit = false;
Processor.Models.Domain.ContentMetadataModel ParentCDef = null;
if (ParentContentId == -1)
{
AllowCDefInherit = false;
}
else
{
AllowCDefInherit = true;
string ParentContentName = MetadataController.getContentNameByID(core, ParentContentId);
ParentCDef = Processor.Models.Domain.ContentMetadataModel.create(core, ParentContentId, true, true);
}
bool NeedFootNote1 = false;
bool NeedFootNote2 = false;
if (contentMetadata.fields.Count > 0)
{
//
// -- header row
Stream.add("<tr>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\"></td>");
if (!AllowCDefInherit)
{
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Inherited*</b></span></td>");
NeedFootNote1 = true;
}
else
{
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Inherited</b></span></td>");
}
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>Field</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>Caption</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>Edit Tab</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"100\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>Default</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>Type</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b>Edit<br>Order</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Active</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b>Read<br>Only</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Auth</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Req</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Unique</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b>Text<br>Buffer</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b><br>Pass</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "<b>Text<br>Scrm</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b><br>HTML</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b>Admin<br>Only</b></span></td>");
Stream.add("<td valign=\"bottom\" width=\"50\" class=\"ccPanelInput\" align=\"left\">" + SpanClassAdminSmall + "<b>Dev<br>Only</b></span></td>");
Stream.add("</tr>");
RecordCount = 0;
//
// Build a select template for Type
//
string TypeSelectTemplate = core.html.selectFromContent("menuname", -1, "Content Field Types", "", "unknown");
//
// Index the sort order
//
List <FieldSortClass> fieldList = new List <FieldSortClass>();
int FieldCount = contentMetadata.fields.Count;
foreach (var keyValuePair in contentMetadata.fields)
{
FieldSortClass fieldSort = new FieldSortClass();
string sortOrder = "";
fieldSort.field = keyValuePair.Value;
sortOrder = "";
if (fieldSort.field.active)
{
sortOrder += "0";
}
else
{
sortOrder += "1";
}
if (fieldSort.field.authorable)
{
sortOrder += "0";
}
else
{
sortOrder += "1";
}
sortOrder += fieldSort.field.editTabName + getIntegerString(fieldSort.field.editSortPriority, 10) + getIntegerString(fieldSort.field.id, 10);
fieldSort.sort = sortOrder;
fieldList.Add(fieldSort);
}
fieldList.Sort((p1, p2) => p1.sort.CompareTo(p2.sort));
StringBuilderLegacyController StreamValidRows = new StringBuilderLegacyController();
var contentFieldsCdef = Processor.Models.Domain.ContentMetadataModel.createByUniqueName(core, "content fields");
foreach (FieldSortClass fieldsort in fieldList)
{
StringBuilderLegacyController streamRow = new StringBuilderLegacyController();
bool rowValid = true;
//
// If Field has name and type, it is locked and can not be changed
//
bool FieldLocked = (fieldsort.field.nameLc != "") && (fieldsort.field.fieldTypeId != 0);
//
// put the menu into the current menu format
//
formFieldId = fieldsort.field.id;
streamRow.add(HtmlController.inputHidden("dtfaID." + RecordCount, formFieldId));
streamRow.add("<tr>");
//
// edit button
//
streamRow.add("<td class=\"ccPanelInput\" align=\"left\">" + AdminUIController.getRecordEditAnchorTag(core, contentFieldsCdef, formFieldId) + "</td>");
//
// Inherited
//
if (!AllowCDefInherit)
{
//
// no parent
//
streamRow.add("<td class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "False</span></td>");
}
else if (fieldsort.field.inherited)
{
//
// inherited property
//
streamRow.add("<td class=\"ccPanelInput\" align=\"center\">" + HtmlController.checkbox("dtfaInherited." + RecordCount, fieldsort.field.inherited) + "</td>");
}
else
{
Processor.Models.Domain.ContentFieldMetadataModel parentField = null;
//
// CDef has a parent, but the field is non-inherited, test for a matching Parent Field
//
if (ParentCDef == null)
{
foreach (KeyValuePair <string, Processor.Models.Domain.ContentFieldMetadataModel> kvp in ParentCDef.fields)
{
if (kvp.Value.nameLc == fieldsort.field.nameLc)
{
parentField = kvp.Value;
break;
}
}
}
if (parentField == null)
{
streamRow.add("<td class=\"ccPanelInput\" align=\"center\">" + SpanClassAdminSmall + "False**</span></td>");
NeedFootNote2 = true;
}
else
{
streamRow.add("<td class=\"ccPanelInput\" align=\"center\">" + HtmlController.checkbox("dtfaInherited." + RecordCount, fieldsort.field.inherited) + "</td>");
}
}
//
// name
//
bool tmpValue = string.IsNullOrEmpty(fieldsort.field.nameLc);
rowValid = rowValid && !tmpValue;
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
streamRow.add(SpanClassAdminSmall + fieldsort.field.nameLc + " </SPAN>");
}
else if (FieldLocked)
{
streamRow.add(SpanClassAdminSmall + fieldsort.field.nameLc + " </SPAN><input type=hidden name=dtfaName." + RecordCount + " value=\"" + fieldsort.field.nameLc + "\">");
}
else
{
streamRow.add(HtmlController.inputText_Legacy(core, "dtfaName." + RecordCount, fieldsort.field.nameLc, 1, 10));
}
streamRow.add("</nobr></td>");
//
// caption
//
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
streamRow.add(SpanClassAdminSmall + fieldsort.field.caption + "</SPAN>");
}
else
{
streamRow.add(HtmlController.inputText_Legacy(core, "dtfaCaption." + RecordCount, fieldsort.field.caption, 1, 10));
}
streamRow.add("</nobr></td>");
//
// Edit Tab
//
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
streamRow.add(SpanClassAdminSmall + fieldsort.field.editTabName + "</SPAN>");
}
else
{
streamRow.add(HtmlController.inputText_Legacy(core, "dtfaEditTab." + RecordCount, fieldsort.field.editTabName, 1, 10));
}
streamRow.add("</nobr></td>");
//
// default
//
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
streamRow.add(SpanClassAdminSmall + GenericController.encodeText(fieldsort.field.defaultValue) + "</SPAN>");
}
else
{
streamRow.add(HtmlController.inputText_Legacy(core, "dtfaDefaultValue." + RecordCount, GenericController.encodeText(fieldsort.field.defaultValue), 1, 10));
}
streamRow.add("</nobr></td>");
//
// type
//
rowValid = rowValid && (fieldsort.field.fieldTypeId > 0);
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
using (var csData = new CsModel(core)) {
csData.openRecord("Content Field Types", (int)fieldsort.field.fieldTypeId);
if (!csData.ok())
{
streamRow.add(SpanClassAdminSmall + "Unknown[" + fieldsort.field.fieldTypeId + "]</SPAN>");
}
else
{
streamRow.add(SpanClassAdminSmall + csData.getText("Name") + "</SPAN>");
}
}
}
else if (FieldLocked)
{
streamRow.add(DbBaseModel.getRecordName <ContentFieldTypeModel>(core.cpParent, (int)fieldsort.field.fieldTypeId) + HtmlController.inputHidden("dtfaType." + RecordCount, (int)fieldsort.field.fieldTypeId));
}
else
{
string TypeSelect = TypeSelectTemplate;
TypeSelect = GenericController.strReplace(TypeSelect, "menuname", "dtfaType." + RecordCount, 1, 99, 1);
TypeSelect = GenericController.strReplace(TypeSelect, "=\"" + fieldsort.field.fieldTypeId + "\"", "=\"" + fieldsort.field.fieldTypeId + "\" selected", 1, 99, 1);
streamRow.add(TypeSelect);
}
streamRow.add("</nobr></td>");
//
// sort priority
//
streamRow.add("<td class=\"ccPanelInput\" align=\"left\"><nobr>");
if (fieldsort.field.inherited)
{
streamRow.add(SpanClassAdminSmall + fieldsort.field.editSortPriority + "</SPAN>");
}
else
{
streamRow.add(HtmlController.inputText_Legacy(core, "dtfaEditSortPriority." + RecordCount, fieldsort.field.editSortPriority.ToString(), 1, 10));
}
streamRow.add("</nobr></td>");
//
// active
//
streamRow.add(configureEdit_CheckBox("dtfaActive." + RecordCount, fieldsort.field.active, fieldsort.field.inherited));
//
// read only
//
streamRow.add(configureEdit_CheckBox("dtfaReadOnly." + RecordCount, fieldsort.field.readOnly, fieldsort.field.inherited));
//
// authorable
//
streamRow.add(configureEdit_CheckBox("dtfaAuthorable." + RecordCount, fieldsort.field.authorable, fieldsort.field.inherited));
//
// required
//
streamRow.add(configureEdit_CheckBox("dtfaRequired." + RecordCount, fieldsort.field.required, fieldsort.field.inherited));
//
// UniqueName
//
streamRow.add(configureEdit_CheckBox("dtfaUniqueName." + RecordCount, fieldsort.field.uniqueName, fieldsort.field.inherited));
//
// text buffered
//
streamRow.add(configureEdit_CheckBox("dtfaTextBuffered." + RecordCount, fieldsort.field.textBuffered, fieldsort.field.inherited));
//
// password
//
streamRow.add(configureEdit_CheckBox("dtfaPassword." + RecordCount, fieldsort.field.password, fieldsort.field.inherited));
//
// scramble
//
streamRow.add(configureEdit_CheckBox("dtfaScramble." + RecordCount, fieldsort.field.scramble, fieldsort.field.inherited));
//
// HTML Content
//
streamRow.add(configureEdit_CheckBox("dtfaHTMLContent." + RecordCount, fieldsort.field.htmlContent, fieldsort.field.inherited));
//
// Admin Only
//
if (core.session.isAuthenticatedAdmin())
{
streamRow.add(configureEdit_CheckBox("dtfaAdminOnly." + RecordCount, fieldsort.field.adminOnly, fieldsort.field.inherited));
}
//
// Developer Only
//
if (core.session.isAuthenticatedDeveloper())
{
streamRow.add(configureEdit_CheckBox("dtfaDeveloperOnly." + RecordCount, fieldsort.field.developerOnly, fieldsort.field.inherited));
}
//
streamRow.add("</tr>");
RecordCount = RecordCount + 1;
//
// rows are built - put the blank rows at the top
//
if (!rowValid)
{
Stream.add(streamRow.text);
}
else
{
StreamValidRows.add(streamRow.text);
}
}
Stream.add(StreamValidRows.text);
Stream.add(HtmlController.inputHidden("dtfaRecordCount", RecordCount));
}
Stream.add("</table>");
//
Stream.add(core.html.getPanelBottom());
if (NeedFootNote1)
{
Stream.add("<br>*Field Inheritance is not allowed because this Content Definition has no parent.");
}
if (NeedFootNote2)
{
Stream.add("<br>**This field can not be inherited because the Parent Content Definition does not have a field with the same name.");
}
}
Stream.add(HtmlController.inputHidden("ReloadCDef", ReloadCDef));
//
// -- assemble form
return(AdminUIController.getToolForm(core, Stream.text, ButtonList));
} catch (Exception ex) {
LogController.logError(core, ex);
return(toolExceptionMessage);
}
}
//
//====================================================================================================
//
public override string GetEditLink(string contentName, string recordID, bool allowCut, string recordName, bool isEditing)
{
return(AdminUIController.getRecordEditAndCutAnchorTag(cp.core, contentName, GenericController.encodeInteger(recordID), allowCut, recordName));
}
//
//========================================================================
//
//========================================================================
//
public static string get(CoreController core)
{
string tempGetForm_Downloads = null;
try {
//
string Button = core.docProperties.getText(RequestNameButton);
if (Button == ButtonCancel)
{
return(core.webServer.redirect("/" + core.appConfig.adminRoute, "Downloads, Cancel Button Pressed"));
}
string ButtonListLeft = "";
string ButtonListRight = "";
string Content = "";
//
if (!core.session.isAuthenticatedAdmin())
{
//
// Must be a developer
//
ButtonListLeft = ButtonCancel;
ButtonListRight = "";
Content = Content + AdminUIController.getFormBodyAdminOnly();
}
else
{
int ContentId = core.docProperties.getInteger("ContentID");
string Format = core.docProperties.getText("Format");
//
// Process Requests
//
if (!string.IsNullOrEmpty(Button))
{
int RowCnt = 0;
switch (Button)
{
case ButtonDelete:
RowCnt = core.docProperties.getInteger("RowCnt");
if (RowCnt > 0)
{
int RowPtr = 0;
for (RowPtr = 0; RowPtr < RowCnt; RowPtr++)
{
if (core.docProperties.getBoolean("Row" + RowPtr))
{
DownloadModel.delete <DownloadModel>(core.cpParent, core.docProperties.getInteger("RowID" + RowPtr));
}
}
}
break;
}
}
//
// Build Tab0
//
string RQS = core.doc.refreshQueryString;
int PageSize = core.docProperties.getInteger(RequestNamePageSize);
if (PageSize == 0)
{
PageSize = 50;
}
int PageNumber = core.docProperties.getInteger(RequestNamePageNumber);
if (PageNumber == 0)
{
PageNumber = 1;
}
string AdminURL = "/" + core.appConfig.adminRoute;
int TopCount = PageNumber * PageSize;
//
const int ColumnCnt = 5;
//
// Setup Headings
//
string[] ColCaption = new string[ColumnCnt + 1];
string[] ColAlign = new string[ColumnCnt + 1];
string[] ColWidth = new string[ColumnCnt + 1];
string[,] Cells = new string[PageSize + 1, ColumnCnt + 1];
int ColumnPtr = 0;
//
ColCaption[ColumnPtr] = " ";
ColAlign[ColumnPtr] = "center";
ColWidth[ColumnPtr] = "10px";
ColumnPtr = ColumnPtr + 1;
//
ColCaption[ColumnPtr] = "Name";
ColAlign[ColumnPtr] = "left";
ColWidth[ColumnPtr] = "";
ColumnPtr = ColumnPtr + 1;
//
ColCaption[ColumnPtr] = "For";
ColAlign[ColumnPtr] = "left";
ColWidth[ColumnPtr] = "200px";
ColumnPtr = ColumnPtr + 1;
//
ColCaption[ColumnPtr] = "Requested";
ColAlign[ColumnPtr] = "left";
ColWidth[ColumnPtr] = "200px";
ColumnPtr = ColumnPtr + 1;
//
ColCaption[ColumnPtr] = "File";
ColAlign[ColumnPtr] = "Left";
ColWidth[ColumnPtr] = "100px";
ColumnPtr = ColumnPtr + 1;
//
// Get Downloads available
//
int DataRowCount = 0;
var downloadList = DbBaseModel.createList <DownloadModel>(core.cpParent, "", "id desc", PageSize, PageNumber);
int RowPointer = 0;
if (downloadList.Count == 0)
{
Cells[0, 1] = "There are no download requests";
RowPointer = 1;
}
else
{
RowPointer = 0;
DataRowCount = DbBaseModel.getCount <DownloadModel>(core.cpParent);
string LinkPrefix = "<a href=\"" + core.appConfig.cdnFileUrl;
string LinkSuffix = "\" target=_blank>Download</a>";
foreach (var download in downloadList)
{
if (RowPointer >= PageSize)
{
break;
}
var requestedBy = DbBaseModel.create <PersonModel>(core.cpParent, download.requestedBy);
Cells[RowPointer, 0] = HtmlController.checkbox("Row" + RowPointer) + HtmlController.inputHidden("RowID" + RowPointer, download.id);
Cells[RowPointer, 1] = download.name;
Cells[RowPointer, 2] = (requestedBy == null) ? "unknown" : requestedBy.name;
Cells[RowPointer, 3] = download.dateRequested.ToString();
if (string.IsNullOrEmpty(download.resultMessage))
{
Cells[RowPointer, 4] = "\r\n<div id=\"pending" + RowPointer + "\">Pending <img src=\"/ccLib/images/ajax-loader-small.gif\" width=16 height=16></div>";
}
else if (!string.IsNullOrEmpty(download.filename.filename))
{
Cells[RowPointer, 4] = "<div id=\"pending" + RowPointer + "\">" + LinkPrefix + download.filename.filename + LinkSuffix + "</div>";
}
else
{
Cells[RowPointer, 4] = "<div id=\"pending" + RowPointer + "\">error</div>";
}
RowPointer = RowPointer + 1;
}
}
StringBuilderLegacyController Tab0 = new StringBuilderLegacyController();
Tab0.add(HtmlController.inputHidden("RowCnt", RowPointer));
string PreTableCopy = "";
string PostTableCopy = "";
string Cell = AdminUIController.getReport(core, RowPointer, ColCaption, ColAlign, ColWidth, Cells, PageSize, PageNumber, PreTableCopy, PostTableCopy, DataRowCount, "ccPanel");
Tab0.add(Cell);
Content = Tab0.text;
ButtonListLeft = ButtonCancel + "," + ButtonRefresh + "," + ButtonDelete;
ButtonListRight = "";
Content = Content + HtmlController.inputHidden(rnAdminSourceForm, AdminFormDownloads);
}
//
string Caption = "Download Manager";
string Description = ""
+ "<p>The Download Manager holds all downloads requested from anywhere on the website. It also provides tools to request downloads from any Content.</p>"
+ "<p>To add a new download of any content in Contensive, click Export on the filter tab of the content listing page. To add a new download from a SQL statement, use Custom Reports under Reports on the Navigator.</p>";
int ContentPadding = 0;
string ContentSummary = "";
tempGetForm_Downloads = AdminUIController.getToolBody(core, Caption, ButtonListLeft, ButtonListRight, true, true, Description, ContentSummary, ContentPadding, Content);
//
core.html.addTitle(Caption);
} catch (Exception ex) {
LogController.logError(core, ex);
}
return(tempGetForm_Downloads);
}
//
//====================================================================================================
//
public override string GetListLink(string contentName)
{
return(AdminUIController.getRecordEditAnchorTag(cp.core, Models.Domain.ContentMetadataModel.createByUniqueName(cp.core, contentName)));
}
