public GlossaryPlaceholderData getGlossary(CmsPage page, int identifier, CmsLanguage language, bool createNewIfDoesNotExist)
{
if (page.ID < 0 || identifier < 0)
{
return(new GlossaryPlaceholderData());
}
string sql = "select glossaryid, sortOrder, viewMode from glossary c where c.pageid = " + page.ID.ToString() + " and c.identifier = " + identifier.ToString() + " and langShortCode like '" + dbEncode(language.shortCode) + "' and deleted is null;";
DataSet ds = this.RunSelectQuery(sql);
if (this.hasSingleRow(ds))
{
DataRow dr = ds.Tables[0].Rows[0];
GlossaryPlaceholderData data = new GlossaryPlaceholderData();
data.GlossaryId = Convert.ToInt32(dr["glossaryid"]);
data.SortOrder = (GlossaryPlaceholderData.GlossarySortOrder)Enum.Parse(typeof(GlossaryPlaceholderData.GlossarySortOrder), dr["sortOrder"].ToString());
data.ViewMode = (GlossaryPlaceholderData.GlossaryViewMode)Enum.Parse(typeof(GlossaryPlaceholderData.GlossaryViewMode), dr["viewMode"].ToString());
return(data);
}
else
{
if (createNewIfDoesNotExist)
{
return(createNewGlossary(page, identifier, language));
}
else
{
throw new Exception("getGlossary database error: placeholder does not exist");
}
}
return(new GlossaryPlaceholderData());
} // getGlossary
public GlossaryData[] getGlossaryData(GlossaryPlaceholderData placeholderData, string letterToDisplay)
{
string sql = "select * from glossarydata where Deleted IS NULL ";
switch (placeholderData.ViewMode)
{
case GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter:
if (letterToDisplay.Length != 1)
{
// throw new ArgumentException("letterToDisplay must be specified!!!");
}
else
{
sql += " AND LEFT(word,1) in ('" + dbEncode(letterToDisplay.ToString().ToLower()) + "','" + dbEncode(letterToDisplay.ToString().ToUpper()) + "') ";
}
break;
case GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList:
// nothing to-do
break;
default:
throw new ArgumentException("invalid ViewMode");
} // switch ViewMode
sql += " AND phGlossaryId = " + placeholderData.GlossaryId + " ";
sql += " ORDER BY left(word,1) "; // always order by the first character of the name
switch (placeholderData.SortOrder)
{
case GlossaryPlaceholderData.GlossarySortOrder.byWord:
sql += ", word ";
break;
case GlossaryPlaceholderData.GlossarySortOrder.byDescription:
sql += ", Description ";
break;
case GlossaryPlaceholderData.GlossarySortOrder.byId:
sql += ", GlossaryDataId ";
break;
default:
throw new ArgumentException("invalid sortOrder");
} // switch SortOrder
// -- run the query
List <GlossaryData> ret = new List <GlossaryData>();
DataSet ds = this.RunSelectQuery(sql);
if (this.hasRows(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
ret.Add(dataFromRow(dr));
} // foreach
}
return(ret.ToArray());
} // getGlossaryData
public override void RenderInViewMode(HtmlTextWriter writer, CmsPage page, int identifier, CmsLanguage langToRenderFor, string[] paramList)
{
GlossaryDb db = new GlossaryDb();
GlossaryPlaceholderData placeholderData = db.getGlossary(page, identifier, langToRenderFor, true);
string letterToDisplay = getLetterToDisplay(placeholderData);
GlossaryData[] items = db.getGlossaryData(placeholderData, letterToDisplay);
string[] charactersWithData = db.getAllCharactersWithData(placeholderData);
StringBuilder html = new StringBuilder();
html.Append(GetHtmlDisplay(page, items, placeholderData, charactersWithData, letterToDisplay));
writer.Write(html.ToString());
} // RenderView
public static string getLetterToDisplay(GlossaryPlaceholderData placeholderData)
{
string letterToDisplay = "";
if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter)
{
string l = PageUtils.getFromForm("l", "");
if (l.Length == 1)
{
letterToDisplay = l[0].ToString();
}
else
{
// placeholderData.ViewMode = GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList;
}
}
return(letterToDisplay);
}
} // saveUpdatedGlossary
private bool RemoveAllExistingGlossaryDataAndInsertNew(GlossaryPlaceholderData placeholder, GlossaryData[] allNewGlossaryData)
{
string delSql = "delete from glossarydata where phGlossaryId = " + placeholder.GlossaryId + " ; ";
int numUpdated = this.RunUpdateQuery(delSql);
if (numUpdated >= 0)
{
if (allNewGlossaryData.Length == 0)
{
return(true);
}
string sql = "INSERT INTO glossarydata (phGlossaryId,isAcronym,word,description) VALUES ";
List <string> sqlVals = new List <string>();
foreach (GlossaryData g in allNewGlossaryData)
{
string Vals = ("(");
Vals += "" + placeholder.GlossaryId.ToString() + ", ";
if (g.isAcronym)
{
Vals += ("1, ");
}
else
{
Vals += ("0, ");
}
Vals += ("'" + dbEncode(g.word) + "', ");
Vals += ("'" + dbEncode(g.description) + "' ");
Vals += (")");
sqlVals.Add(Vals);
} // foreach
sql = sql + String.Join(",", sqlVals.ToArray()) + ";";
int numInserted = this.RunUpdateQuery(sql);
if (numInserted == allNewGlossaryData.Length)
{
return(true);
}
}
return(false);
}
} // getGlossaryData
public string[] getAllCharactersWithData(GlossaryPlaceholderData placeholderData)
{
string sql = "SELECT distinct UPPER(left(word,1)) as c FROM glossarydata g ";
sql += " where phGlossaryId = " + placeholderData.GlossaryId.ToString() + " ";
sql += " order by UPPER(left(word,1));";
DataSet ds = this.RunSelectQuery(sql);
List <string> ret = new List <string>();
if (this.hasRows(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
ret.Add(dr["c"].ToString());
} // foreach
}
return(ret.ToArray());
} // getAllCharactersWithData
} // getGlossary
public GlossaryPlaceholderData createNewGlossary(CmsPage page, int identifier, CmsLanguage language)
{
GlossaryPlaceholderData data = new GlossaryPlaceholderData();
string sql = "insert into glossary (pageid, identifier, langShortCode, sortOrder, ViewMode) values (";
sql = sql + page.ID.ToString() + "," + identifier.ToString() + ",";
sql += "'" + dbEncode(language.shortCode) + "', ";
sql = sql + "'" + Enum.GetName(typeof(GlossaryPlaceholderData.GlossarySortOrder), data.SortOrder) + "', ";
sql = sql + "'" + Enum.GetName(typeof(GlossaryPlaceholderData.GlossaryViewMode), data.ViewMode) + "' ";
sql += "); ";
int newId = this.RunInsertQuery(sql);
if (newId > -1)
{
page.setLastUpdatedDateTimeToNow();
}
return(data);
} // createNewGlossary
} // RenderView
public override Rss.RssItem[] GetRssFeedItems(CmsPage page, CmsPlaceholderDefinition placeholderDefinition, CmsLanguage langToRenderFor)
{
GlossaryDb db = new GlossaryDb();
GlossaryPlaceholderData placeholderData = db.getGlossary(page, placeholderDefinition.Identifier, langToRenderFor, true);
GlossaryPlaceholderData.GlossaryViewMode origViewMode = placeholderData.ViewMode;
// -- gets all glossary items (regardless of the ViewMode)
GlossaryData[] items = db.getGlossaryData(placeholderData.GlossaryId);
// -- each glossary item gets its own rssItem
List <Rss.RssItem> ret = new List <Rss.RssItem>();
foreach (GlossaryData glData in items)
{
Rss.RssItem rssItem = new Rss.RssItem();
rssItem = base.InitRssItem(rssItem, page, langToRenderFor);
rssItem.Description = glData.description;
// -- setup the proper link
switch (placeholderData.ViewMode)
{
case GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter:
Dictionary <string, string> urlParams = new Dictionary <string, string>();
urlParams.Add("l", glData.word.ToUpper()[0].ToString());
rssItem.Link = new Uri(page.getUrl(urlParams, langToRenderFor));
break;
case GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList:
// nothing to do
break;
default:
throw new Exception("Error: invalid GlossaryViewMode");
} // switch
}
return(ret.ToArray());
}
} // createNewGlossary
public bool saveUpdatedGlossary(CmsPage page, int identifier, CmsLanguage language, GlossaryPlaceholderData data, GlossaryData[] allGlossaryData)
{
string sql = "update glossary set ";
sql += " sortOrder = '" + Enum.GetName(typeof(GlossaryPlaceholderData.GlossarySortOrder), data.SortOrder) + "', ";
sql += " ViewMode = '" + Enum.GetName(typeof(GlossaryPlaceholderData.GlossaryViewMode), data.ViewMode) + "' ";
sql += " where glossaryid = " + data.GlossaryId.ToString();
int numAffected = this.RunUpdateQuery(sql);
if (numAffected > 0)
{
if (RemoveAllExistingGlossaryDataAndInsertNew(data, allGlossaryData))
{
return(page.setLastUpdatedDateTimeToNow());
}
}
return(false);
} // saveUpdatedGlossary
public override void RenderInEditMode(HtmlTextWriter writer, CmsPage page, int identifier, CmsLanguage langToRenderFor, string[] paramList)
{
string ControlId = "Glossary_" + page.ID.ToString() + "_" + identifier.ToString() + "_" + langToRenderFor.shortCode;
string renderEditorToDivId = ControlId + "RenderArea";
string renderJsonToFormId = ControlId + "JsonFormData";
string jsonDataVarName = ControlId + "_GlossaryJsonData";
GlossaryDb db = new GlossaryDb();
GlossaryPlaceholderData placeholderData = db.getGlossary(page, identifier, langToRenderFor, true);
string action = PageUtils.getFromForm(ControlId + "_action", "");
if (String.Compare(action, "updateGlossary", true) == 0)
{
string receivedJSONData = PageUtils.getFromForm(renderJsonToFormId, "");
GlossaryData[] newData = fromJSON(receivedJSONData);
placeholderData.SortOrder = (GlossaryPlaceholderData.GlossarySortOrder)PageUtils.getFromForm(ControlId + "SortOrder", typeof(GlossaryPlaceholderData.GlossarySortOrder), placeholderData.SortOrder);
placeholderData.ViewMode = (GlossaryPlaceholderData.GlossaryViewMode)PageUtils.getFromForm(ControlId + "ViewMode", typeof(GlossaryPlaceholderData.GlossaryViewMode), placeholderData.ViewMode);
bool b = db.saveUpdatedGlossary(page, identifier, langToRenderFor, placeholderData, newData);
if (b)
{
GlossaryData[] dataToSave = db.getGlossaryData(placeholderData, "");
string jsonToSave = getJSVariableStatement(jsonDataVarName, dataToSave);
try
{
string jsonFilename = System.Web.Hosting.HostingEnvironment.MapPath(CmsContext.ApplicationPath + "_system/writable/Glossary/" + jsonDataVarName + ".js");
System.IO.File.Delete(jsonFilename);
System.IO.File.WriteAllText(jsonFilename, jsonToSave);
}
catch
{ }
}
} // if updateGlossary
StringBuilder html = new StringBuilder();
html.Append(PageUtils.getHiddenInputHtml(ControlId + "_action", "updateGlossary"));
string EOL = Environment.NewLine;
html.Append("<p><strong>Glossary Display Configuration:</strong></p>");
html.Append("<table>");
if (CmsConfig.Languages.Length > 1)
{
html.Append("<tr>");
html.Append("<td>Language:</td><td>" + langToRenderFor.shortCode + "</td>");
html.Append("</tr>");
}
html.Append("<tr>");
html.Append("<td>Display Mode: </td>");
html.Append("<td>");
html.Append(PageUtils.getDropDownHtml(ControlId + "ViewMode", ControlId + "ViewMode", Enum.GetNames(typeof(GlossaryPlaceholderData.GlossaryViewMode)), Enum.GetName(typeof(GlossaryPlaceholderData.GlossaryViewMode), placeholderData.ViewMode)));
html.Append("</td>");
html.Append("</tr>");
html.Append("<tr>");
html.Append("<td>Output Sorting: </td>");
html.Append("<td>");
html.Append(PageUtils.getDropDownHtml(ControlId + "SortOrder", ControlId + "SortOrder", Enum.GetNames(typeof(GlossaryPlaceholderData.GlossarySortOrder)), Enum.GetName(typeof(GlossaryPlaceholderData.GlossarySortOrder), placeholderData.SortOrder)));
html.Append("</td>");
html.Append("</tr>");
html.Append("</table>" + EOL);
// -- glossary data
// note: the form is linked to GlossaryEditor.js
GlossaryData[] items = db.getGlossaryData(placeholderData, "");
html.Append("<p><strong>Glossary Entries:</strong></p>");
html.Append("<div id=\"" + renderEditorToDivId + "\"></div>");
html.Append("<input type=\"button\" onclick=\"AddGlossaryElement('" + renderEditorToDivId + "');\" value=\"add new glossary entry\">" + Environment.NewLine);
// -- the JSON data is passed to the server through this hidden form element
html.Append(PageUtils.getHiddenInputHtml(renderJsonToFormId, renderJsonToFormId, ""));
page.HeadSection.AddJavascriptFile(JavascriptGroup.Library, "js/_system/json2.js");
page.HeadSection.AddJavascriptFile(JavascriptGroup.FrontEnd, "js/_system/GlossaryEditor.js");
page.HeadSection.AddJSStatements(getJSVariableStatement(jsonDataVarName, items));
page.HeadSection.AddJSOnReady("var " + ControlId + "Instance = new GlossaryEditor('" + renderEditorToDivId + "', '" + renderJsonToFormId + "', JSON.parse(" + jsonDataVarName + ")); ");
page.HeadSection.AddJSOnReady("GlossaryEditorInstances[GlossaryEditorInstances.length] = " + ControlId + "Instance; ");
page.HeadSection.AddJSOnReady("" + ControlId + "Instance.updateDisplay();");
writer.Write(html.ToString());
} // RenderEdit
public static string GetHtmlDisplay(CmsPage page, GlossaryData[] items, GlossaryPlaceholderData placeholderData, string[] charactersWithData, string letterToDisplay)
{
StringBuilder html = new StringBuilder();
html.Append("<div class=\"Glossary\">" + Environment.NewLine);
// -- output JumpLinks
html.Append("<div class=\"JumpLinks\">");
string JumpLinksSeperator = " | ";
List <string> jumpLinks = new List <string>();
if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter && letterToDisplay != "")
{
jumpLinks.Add("<a href=\"" + page.Url + "\" title=\"view entire glossary\">[all]</a>");
}
char startChar = 'A';
char lastChar = 'Z'; lastChar++;
char currentChar = startChar;
do
{
string link = "";
bool outputA = false;
if (StringUtils.IndexOf(charactersWithData, currentChar.ToString(), StringComparison.CurrentCultureIgnoreCase) > -1)
{
outputA = true;
string url = "";
if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter)
{
NameValueCollection pageParams = new NameValueCollection();
pageParams.Add("l", currentChar.ToString());
url = CmsContext.getUrlByPagePath(page.Path, pageParams);
}
else if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList)
{
url = "#letter_" + currentChar.ToString();
}
link += "<a href=\"" + url + "\">";
}
link += currentChar.ToString();
if (outputA)
{
link += "</a>";
}
jumpLinks.Add(link);
currentChar++;
}while (currentChar != lastChar);
string jumpLinksHtml = String.Join(JumpLinksSeperator, jumpLinks.ToArray());
html.Append(jumpLinksHtml);
html.Append("</div>"); // JumpLinks
// -- output terms
switch (placeholderData.ViewMode)
{
case GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter:
if (letterToDisplay == "")
{
startChar = 'A';
lastChar = 'Z'; lastChar++;
}
else
{
startChar = letterToDisplay[0];
lastChar = letterToDisplay[0]; lastChar++;
}
break;
case GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList:
startChar = 'A';
lastChar = 'Z'; lastChar++;
break;
default:
throw new ArgumentException("invalid GlossaryViewMode");
} // switch viewmode
currentChar = startChar;
html.Append("<table class=\"glossaryitems\">");
do
{
html.Append("<tr><td class=\"LetterHeading\" colspan=\"2\">");
html.Append("<a name=\"letter_" + currentChar.ToString() + "\"></a>");
html.Append("<h2>" + currentChar + "</h2>");
html.Append("</td></tr>" + Environment.NewLine);
GlossaryData[] itemsToDisplay = new GlossaryData[0];
if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.SinglePageWithJumpList || letterToDisplay == "")
{
itemsToDisplay = GlossaryData.getItemsStartingWithChar(items, currentChar);
}
else if (placeholderData.ViewMode == GlossaryPlaceholderData.GlossaryViewMode.PagePerLetter)
{
itemsToDisplay = items;
}
bool oddRow = true;
foreach (GlossaryData item in itemsToDisplay)
{
string cssClass = "even";
if (oddRow)
{
cssClass = "odd";
}
html.Append("<tr class=\"" + cssClass + "\">");
html.Append("<td class=\"word " + cssClass + "\">" + item.word + "</td>");
html.Append("<td class=\"description " + cssClass + "\">" + item.description + "</td>");
html.Append("</tr>" + Environment.NewLine);
oddRow = !oddRow;
} // foreach glossarydata item
currentChar++;
} while (currentChar != lastChar);
html.Append("</table>");
html.Append("</div>"); // glossary
return(html.ToString());
}