private TreeNode AddFunctionBranch(Term functionTerm)
{
TreeNode functionNode = new TreeNode(functionTerm.Name, functionTerm.Name, "/_layouts/Images/FOLDER.GIF");
//WBLogging.Generic.Verbose("Adding the funciton node: " + functionTerm.Name);
foreach (Term recordsGrouping in recordsTypesTaxonomy.TermSet.Terms)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypesTaxonomy, recordsGrouping);
if (recordsGrouping.IsAvailableForTagging == false)
{
continue;
}
if (!recordsType.AllowDocumentRecords)
{
continue;
}
if (string.IsNullOrEmpty(recordsType.DefaultFunctionalAreaUIControlValue) || recordsType.DefaultFunctionalAreaUIControlValue.Contains(functionTerm.Id.ToString()))
{
functionNode.ChildNodes.Add(AddRecordsTypeBranch(functionTerm, recordsType));
}
}
return(functionNode);
}
private TreeNode createNodes(WBRecordsType recordsType)
{
TreeNode node = new TreeNode();
node.Text = recordsType.Name;
node.NavigateUrl = "javascript: WorkBoxFramework_triggerWebPartUpdate('" + recordsType.Id.ToString() + "'); ";
node.Value = recordsType.Id.WBxToString();
Dictionary <String, TreeNode> allNodes = new Dictionary <String, TreeNode>();
foreach (Term term in recordsType.Term.Terms)
{
WBRecordsType childRecordsType = new WBRecordsType(recordsType.Taxonomy, term);
if (term.IsAvailableForTagging && childRecordsType.AllowWorkBoxRecords)
{
TreeNode childNode = createNodes(childRecordsType);
allNodes.Add(childNode.Text, childNode);
}
}
List <String> names = new List <String>(allNodes.Keys);
names.Sort();
foreach (String name in names)
{
node.ChildNodes.Add(allNodes[name]);
}
return(node);
}
private TreeNode AddRecordsTypeBranch(Term functionTerm, WBRecordsType recordsType)
{
TreeNode recordsTypeNode = new TreeNode(recordsType.Name, recordsType.Name, "/_layouts/Images/EMMTerm.png");
//WBLogging.Generic.Verbose("Adding the records type node: " + recordsType.Name);
foreach (Term childRecordsTypeTerm in recordsType.Term.Terms)
{
if (!childRecordsTypeTerm.IsAvailableForTagging)
{
continue;
}
WBRecordsType childRecordsType = new WBRecordsType(recordsTypesTaxonomy, childRecordsTypeTerm);
if (!childRecordsType.AllowDocumentRecords)
{
continue;
}
if (functionTerm == null || string.IsNullOrEmpty(childRecordsType.DefaultFunctionalAreaUIControlValue) || recordsType.DefaultFunctionalAreaUIControlValue.Contains(functionTerm.Id.ToString()))
{
recordsTypeNode.ChildNodes.Add(AddRecordsTypeBranch(functionTerm, childRecordsType));
}
}
return(recordsTypeNode);
}
private void RefreshBrowsableTreeView()
{
switch (SelectedView)
{
case VIEW_BY_RECORDS_TYPE:
{
// TreeViewTermCollection collection = new TreeViewTermCollection();
// collection.Add(new TreeViewTerm(recordsTypesTaxonomy.TermSet));
// BrowsableTreeView.DataSource = collection;
// BrowsableTreeView.DataBind();
foreach (Term term in recordsTypesTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypesTaxonomy, term);
if (recordsType.AllowDocumentRecords)
{
BrowsableTreeView.Nodes.Add(AddRecordsTypeBranch(null, recordsType));
}
}
}
break;
}
case VIEW_BY_FUNCTION_THEN_TYPE:
{
//WBTaxonomy functionalAreasTaxonomy = WBTaxonomy.GetFunctionalAreas(recordsTypesTaxonomy);
//BrowsableTreeView.DataSource = null;
foreach (Term term in functionalAreaTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
BrowsableTreeView.Nodes.Add(AddFunctionBranch(term));
}
}
break;
}
case VIEW_BY_SUBJECT:
{
foreach (Term term in subjectTagsTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
BrowsableTreeView.Nodes.Add(AddSubjectBranch(term));
}
}
break;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
SPWeb web = SPContext.Current.Web;
SPSite site = SPContext.Current.Site;
WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
string teamGUIDString = "";
Team = WBTeam.GetFromTeamSite(SPContext.Current);
if (Team == null)
{
NotSetupText = "(<i>This site doesn't appear to be a team site so this web part wont work here.</i>)";
return;
}
teamGUIDString = WBExtensions.WBxToString(Team.Id);
string recordsTypesListUrl = Team.RecordsTypesListUrl;
/*
* For the moment this web part is just going to list all of the available records types so the following code is not needed
*
* if (recordsTypesListUrl == null || recordsTypesListUrl == "")
* {
* //recordsTypesListUrl = web.Url + "/Lists/Configure%20Teams%20Records%20Classes";
* NotSetupText = "(<i>The team has no records types list setup yet.</i>)";
* return;
* }
*/
string selectedRecordsTypeGUID = Request.QueryString["recordsTypeGUID"];
try
{
foreach (Term term in recordsTypesTaxonomy.TermSet.Terms)
{
WBRecordsType recordsClass = new WBRecordsType(recordsTypesTaxonomy, term);
TreeNode node = createNodes(recordsClass);
RecordsTypeTreeView.Nodes.Add(node);
RecordsTypeTreeView.CollapseAll();
expandByRecordsTypeGUID(RecordsTypeTreeView.Nodes, selectedRecordsTypeGUID);
}
}
catch (Exception exception)
{
WBUtils.logMessage("The error message was: " + exception.Message);
}
}
protected void Page_Load(object sender, EventArgs e)
{
string csv = "";
WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
foreach (Term classTerm in recordsTypes.TermSet.Terms)
{
WBRecordsType recordsClass = new WBRecordsType(recordsTypes, classTerm);
csv += AddRecordsType(recordsClass);
}
CSVOutput.Text = csv;
}
protected void Page_Load(object sender, EventArgs e)
{
WBRecordsType recordsType = WorkBox.RecordsType;
if (recordsType.WorkBoxReferenceIDRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN)
{
showReferenceID = true;
}
if (recordsType.WorkBoxReferenceDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN)
{
showReferenceDate = true;
}
if (!IsPostBack)
{
WorkBoxTitle.Text = WorkBox.Title;
OwningTeam.Text = WorkBox.OwningTeam.Name;
FunctionalArea.Text = WorkBox.FunctionalArea(WBTaxonomy.GetFunctionalAreas(WorkBox.RecordsTypes)).Names();
RecordsType.Text = recordsType.FullPath;
WorkBoxTemplate.Text = WorkBox.Template.Title;
WorkBoxStatus.Text = WorkBox.Status;
WorkBoxURL.Text = WorkBox.Url;
WorkBoxShortTitle.Text = WorkBox.ShortTitle;
WorkBoxPrettyTitle.Text = WorkBox.Web.Title;
if (showReferenceID)
{
ReferenceID.Text = WorkBox.ReferenceID;
}
if (showReferenceDate)
{
if (WorkBox.ReferenceDateHasValue)
{
ReferenceDate.Text = WorkBox.ReferenceDate.ToShortDateString();
}
}
WBAction editAction = WorkBox.GetAction(WBAction.ACTION_KEY__EDIT_PROPERTIES);
EditButton.Enabled = editAction.IsEnabled;
}
}
internal void PopulateTreeNode(WBLocationTreeState treeState, TreeNode node, String viewMode)
{
WBLogging.Debug("Looking for WBFolderTreeNode with path: " + node.ValuePath);
WBFolderTreeNode folderTreeNode = this.GetFolderTreeNode(node.ValuePath);
if (folderTreeNode == null)
{
WBLogging.Debug("Did not find WBFolderTreeNode at: " + node.ValuePath);
return;
}
if (folderTreeNode is WBRecordsTypeTreeNode)
{
WBLogging.Debug("Expanding a records type node: " + node.Text);
WBRecordsTypeTreeNode recordsTypeNode = (WBRecordsTypeTreeNode)folderTreeNode;
WBRecordsType recordsType = recordsTypeNode.RecordsType;
TermCollection childTerms = recordsType.Term.Terms;
if (childTerms.Count > 0)
{
PopulateWithRecordsTypes(treeState, node.ChildNodes, viewMode, recordsTypeNode.Folder, recordsTypeNode.FunctionalArea, recordsType.Taxonomy, childTerms);
}
else
{
if (viewMode != VIEW_MODE__NEW)
{
PopulateWithSubFolders(treeState, node.ChildNodes, viewMode, recordsTypeNode.Folder);
}
}
}
else if (folderTreeNode is WBFolderTreeNode)
{
WBLogging.Debug("Expanding a folder node: " + node.Text);
// You shouldn't be here if the view mode was NEW !
PopulateWithSubFolders(treeState, node.ChildNodes, viewMode, folderTreeNode.Folder);
}
else
{
WBLogging.Debug("NOT expanding an unrecognised node: " + node.Text + " of type: " + node.GetType());
}
}
private TreeNode createNodes(WBRecordsType recordsType, WBTeam owningTeam, bool forFiltering)
{
String commandURL = "";
if (forFiltering)
{
commandURL = "javascript: WorkBoxFramework_triggerWebPartUpdate('" + recordsType.Id.ToString() + "'); ";
}
else
{
commandURL = "javascript: WorkBoxFramework_relativeCommandAction('NewWorkBox.aspx?workBoxCollectionUrl=" + recordsType.WorkBoxCollectionUrl + "&recordsTypeGUID=" + recordsType.Id.ToString() + "&owningTeamGUID=" + owningTeam.Id.ToString() + "', 0, 0); ";
}
TreeNode node = new TreeNode();
node.Text = recordsType.Name;
node.NavigateUrl = commandURL;
node.Value = recordsType.Id.WBxToString();
Dictionary <String, TreeNode> allNodes = new Dictionary <String, TreeNode>();
foreach (Term term in recordsType.Term.Terms)
{
WBRecordsType childRecordsType = new WBRecordsType(recordsType.Taxonomy, term);
if (term.IsAvailableForTagging && childRecordsType.AllowWorkBoxRecords)
{
TreeNode childNode = createNodes(childRecordsType, owningTeam, forFiltering);
allNodes.Add(childNode.Text, childNode);
}
}
List <String> names = new List <String>(allNodes.Keys);
names.Sort();
foreach (String name in names)
{
node.ChildNodes.Add(allNodes[name]);
}
return(node);
}
protected void Page_Load(object sender, EventArgs e)
{
WBRecordsType recordsType = WorkBox.RecordsType;
if (recordsType.WorkBoxReferenceIDRequirement == WBRecordsType.METADATA_REQUIREMENT__HIDDEN)
{
showReferenceID = false;
}
if (recordsType.WorkBoxReferenceDateRequirement == WBRecordsType.METADATA_REQUIREMENT__HIDDEN)
{
showReferenceDate = false;
}
if (!IsPostBack)
{
WorkBoxTitle.Text = WorkBox.Title;
OwningTeam.Text = WorkBox.OwningTeam.Name;
FunctionalArea.Text = WorkBox.FunctionalArea(WBTaxonomy.GetFunctionalAreas(WorkBox.RecordsTypes)).Names();
RecordsType.Text = recordsType.FullPath;
WorkBoxTemplate.Text = WorkBox.Template.Title;
WorkBoxStatus.Text = WorkBox.Status;
WorkBoxURL.Text = WorkBox.Url;
WorkBoxShortTitle.Text = WorkBox.ShortTitle;
WorkBoxPrettyTitle.Text = WorkBox.Web.Title;
WorkBoxShortTitle.Focus();
if (showReferenceID)
{
ReferenceID.Text = WorkBox.ReferenceID;
}
if (showReferenceDate)
{
if (WorkBox.ReferenceDateHasValue)
{
ReferenceDate.SelectedDate = WorkBox.ReferenceDate;
}
}
}
}
private String AddRecordsType(WBRecordsType recordsType)
{
List <String> properties = recordsType.GetAllPropertyValues();
List <String> csvValues = new List <String>();
foreach (String property in properties)
{
csvValues.Add("\"" + property + "\"");
}
string csvText = "";
csvText += String.Join(",", csvValues.ToArray()) + "\n";
foreach (Term child in recordsType.Term.Terms)
{
csvText += AddRecordsType(new WBRecordsType(recordsType.Taxonomy, child));
}
return(csvText);
}
DataView GetTemplatesDataSource(WBCollection collection, WBRecordsType recordsType)
{
// Create a table to store data for the DropDownList control.
DataTable dataTable = new DataTable();
// Define the columns of the table.
dataTable.Columns.Add(new DataColumn("WorkBoxTemplateTextField", typeof(String)));
dataTable.Columns.Add(new DataColumn("WorkBoxTemplateValueField", typeof(String)));
List <WBTemplate> templates = collection.ActiveTemplates(recordsType);
foreach (WBTemplate template in templates)
{
dataTable.Rows.Add(CreateRow(template.Title, template.ID.ToString(), dataTable));
}
// Create a DataView from the DataTable to act as the data source
// for the DropDownList control.
DataView dataView = new DataView(dataTable);
return(dataView);
}
/*
* protected void RecordsLibraryFolders_SelectedNodeChanged(object sender, EventArgs e)
* {
* WBLogging.Debug("Call to RecordsLibraryFolders_SelectedNodeChanged");
*
* String selectedPath = manager.GetSelectedPath(Request);
* if (!String.IsNullOrEmpty(selectedPath))
* {
* ProcessSelection(selectedPath);
* }
* }
*/
protected void ProcessSelection(String selectedPath)
{
if (!String.IsNullOrEmpty(selectedPath))
{
if (!String.IsNullOrEmpty(HiddenSortColumn.Value))
{
ViewState["SortColumn"] = HiddenSortColumn.Value;
ViewState["SortDirection"] = HiddenSortDirection.Value;
}
// Now for the bit where the path is analysed to pick out the selected functional area and the records type:
String[] pathSteps = selectedPath.Split('/');
// We're only interested in selections of 3rd level 'folders' that are: functional area / records type / records type ... or below.
if (pathSteps.Length < 3)
{
return;
}
WBTerm functionalArea = manager.FunctionalAreasTaxonomy.GetSelectedWBTermByPath(pathSteps[0]);
if (functionalArea == null)
{
WBLogging.Debug("The functional area part of the selected path came back null: " + selectedPath);
return;
}
Term recordsTypeTerm = manager.RecordsTypesTaxonomy.GetOrCreateSelectedTermByPath(pathSteps[1] + "/" + pathSteps[2]);
if (recordsTypeTerm == null)
{
WBLogging.Debug("The records type part of the selected path came back null: " + selectedPath);
return;
}
WBRecordsType recordsType = new WBRecordsType(manager.RecordsTypesTaxonomy, recordsTypeTerm);
RenderRecordsLibraryFoldersSelection(selectedPath);
}
}
public TreeViewLocation(TreeViewLocation parent, WBRecordsManager manager, string mode, string minimumProtectiveZone, WBTerm functionalArea, WBRecordsType recordsType)
{
_type = LOCATION_TYPE__RECORDS_TYPE;
_parent = parent;
_manager = manager;
_mode = mode;
_minimumProtectiveZone = minimumProtectiveZone;
_functionalArea = functionalArea;
_recordsType = recordsType;
_name = _recordsType.Name;
_guidString = _recordsType.Id.ToString();
if (_mode != VIEW_MODE__NEW)
{
_folder = _parent._folder.WBxGetSubFolder(recordsType.Name);
if (_folder == null)
{
WBLogging.Debug("Did not find folder for: " + recordsType.Name);
}
}
}
protected void ProcessSelection(String selectedPath)
{
WBLogging.Debug("In ProcessSelection(): selectedPath = " + selectedPath);
if (!String.IsNullOrEmpty(selectedPath))
{
if (string.IsNullOrEmpty(selectedPath))
{
selectedPath = "/";
}
selectedPath = selectedPath.Replace("(root)", "");
if (string.IsNullOrEmpty(selectedPath))
{
selectedPath = "/";
}
SelectedFolderPath.Text = selectedPath;
// Now for the bit where the path is analysed to pick out the selected functional area and the records type:
String[] pathSteps = selectedPath.Split('/');
// We're only interested in selections of 3rd level 'folders' that are: functional area / records type / records type ... or below.
if (pathSteps.Length < 3)
{
return;
}
WBTerm functionalArea = manager.FunctionalAreasTaxonomy.GetSelectedWBTermByPath(pathSteps[0]);
if (functionalArea == null)
{
WBLogging.Debug("The functional area part of the selected path came back null: " + selectedPath);
return;
}
Term recordsTypeTerm = manager.RecordsTypesTaxonomy.GetOrCreateSelectedTermByPath(pathSteps[1] + "/" + pathSteps[2]);
if (recordsTypeTerm == null)
{
WBLogging.Debug("The records type part of the selected path came back null: " + selectedPath);
return;
}
WBRecordsType recordsType = new WBRecordsType(manager.RecordsTypesTaxonomy, recordsTypeTerm);
process.FunctionalAreaUIControlValue = functionalArea.UIControlValue;
process.RecordsTypeUIControlValue = recordsType.UIControlValue;
WBLogging.Debug("Set the new records type to be: " + process.RecordsTypeUIControlValue);
// Finally let's see if there is a specific record being selected as well:
if (!process.IsReplaceActionToCreateNewSeries)
{
WBRecord record = manager.Libraries.GetRecordByPath(selectedPath);
SelectedRecordID.Text = record.RecordID;
process.ToReplaceRecordID = record.RecordID;
process.ToReplaceRecordPath = selectedPath;
process.ToReplaceShortTitle = record.Title;
process.ToReplaceSubjectTagsUIControlValue = record.SubjectTagsUIControlValue;
}
PublishingProcessJSON.Value = WBUtils.SerializeToCompressedJSONForURI(process);
}
else
{
WBLogging.Debug("In LibraryLocations_SelectedNodeChanged(): Selected path was null");
}
}
protected void Page_Load(object sender, EventArgs e)
{
webPart = this.Parent as WorkBoxExplorer;
SPWebPartManager webPartManager = (SPWebPartManager)WebPartManager.GetCurrentWebPartManager(this.Page);
if ((SPContext.Current.FormContext.FormMode == SPControlMode.Edit) ||
(webPartManager.DisplayMode == WebPartManager.EditDisplayMode))
{
InEditMode = true;
}
SearchScope = WBUtils.UrlDataEncode(webPart.SearchScope);
SelectedWorkBoxes.AllowSorting = true;
SelectedWorkBoxes.Sorting += new GridViewSortEventHandler(SelectedWorkBoxes_Sorting);
SelectedWorkBoxes.AllowPaging = true;
SelectedWorkBoxes.PageIndexChanging += new GridViewPageEventHandler(SelectedWorkBoxes_PageIndexChanging);
SelectedWorkBoxes.PagerSettings.Mode = PagerButtons.Numeric;
SelectedWorkBoxes.PagerSettings.Position = PagerPosition.Bottom;
SelectedWorkBoxes.PagerSettings.PageButtonCount = 50;
SelectedWorkBoxes.PagerSettings.Visible = true;
SelectedWorkBoxes.PageSize = 30;
// this odd statement is required in order to get the pagination to work with an SPGridView!
SelectedWorkBoxes.PagerTemplate = null;
CoreResultsWebPart.UseLocationVisualization = false;
CoreResultsWebPart.PropertiesToRetrieve = string.Empty;
CoreResultsWebPart.SelectColumns = @"<Columns> <Column Name=""WorkId""/> <Column Name=""Rank""/> <Column Name=""Title""/> <Column Name=""Author""/> <Column Name=""Size""/> <Column Name=""Path""/> <Column Name=""Description""/> <Column Name=""Write""/> <Column Name=""SiteName""/> <Column Name=""CollapsingStatus""/> <Column Name=""HitHighlightedSummary""/> <Column Name=""HitHighlightedProperties""/> <Column Name=""ContentClass""/> <Column Name=""IsDocument""/> <Column Name=""PictureThumbnailURL""/> <Column Name=""PopularSocialTags""/> <Column Name=""PictureWidth""/> <Column Name=""PictureHeight""/> <Column Name=""DatePictureTaken""/> <Column Name=""ServerRedirectedURL""/> <Column Name=""SiteTitle""/> <Column Name=""SPWebURL""/> <Column Name=""OwningTeam""/> </Columns>";
CoreResultsWebPart.XslLink = "/Style Library/WBF/wb-explorer-search-results.xslt";
//CoreResultsWebPart.DisplayAlertMeLink = true;
//CoreResultsWebPart.AllowConnect = false;
SPWeb web = SPContext.Current.Web;
SPSite site = SPContext.Current.Site;
WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
string teamGUIDString = "";
Team = WBTeam.GetFromTeamSite(SPContext.Current);
if (Team == null)
{
return;
}
if (Team.IsCurrentUserTeamOwnerOrSystemAdmin())
{
canSaveDefaultView = true;
}
// RefinementByOwningTeam = "owningteam%3D%22%23" + (Team.Id.ToString().Replace(" ", "%20").Replace("#", "%23").Replace("-", "%2D")) + "%22";
// RefinementByOwningTeam = "owningteam%3D%22" + (Team.Name.ToString().Replace(" ", "%20").Replace("#", "%23").Replace("-", "%2D")) + "%22";
RefinementByOwningTeam = WBUtils.UrlDataEncode("owningteam=\"" + Team.Name + "\"");
teamGUIDString = WBExtensions.WBxToString(Team.Id);
string recordsTypesListUrl = Team.RecordsTypesListUrl;
if (recordsTypesListUrl == null || recordsTypesListUrl == "")
{
//recordsTypesListUrl = web.Url + "/Lists/Configure%20Teams%20Records%20Classes";
NotSetupText = "(<i>The team has no records types list setup yet.</i>)";
return;
}
// urm ... this is a real mess - a hidden field and a view state - it's a mashup mess!!
String selectedRecordsTypeGUID = Request.QueryString["recordsTypeGUID"];
if (String.IsNullOrEmpty(selectedRecordsTypeGUID))
{
String guidString = HiddenRecordsTypeGUIDField.Value;
if (guidString != null && guidString != "")
{
SelectedRecordsTypeGUID = guidString;
}
}
else
{
SelectedRecordsTypeGUID = selectedRecordsTypeGUID;
HiddenRecordsTypeGUIDField.Value = selectedRecordsTypeGUID;
}
using (SPWeb configWeb = site.OpenWeb(recordsTypesListUrl))
{
ConfigurationList = configWeb.GetList(recordsTypesListUrl);
if (ConfigurationList != null)
{
if (!ConfigurationList.Fields.ContainsField("Records Class"))
{
ConfigurationList = null;
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " has no 'Records Class' column.</i>)";
}
}
else
{
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " was not set up correctly or does not exist.</i>)";
}
if (ConfigurationList != null)
{
TeamAdminRecordsTypesTreeView.Nodes.Clear();
OurWorkRecordsTypesTreeView.Nodes.Clear();
CouncilWideRecordsTypesTreeView.Nodes.Clear();
TeamAdminRecordsTypesFilter.Nodes.Clear();
OurWorkRecordsTypesFilter.Nodes.Clear();
CouncilWideRecordsTypesFilter.Nodes.Clear();
foreach (SPListItem item in ConfigurationList.Items)
{
try
{
WBRecordsType recordsClass = new WBRecordsType(recordsTypesTaxonomy, WBExtensions.WBxGetColumnAsString(item, "Records Class"));
TreeNode createNewNodes = createNodes(recordsClass, Team, false);
TreeNode forFilteringNodes = createNodes(recordsClass, Team, true);
string groupName = item.WBxGetColumnAsString("Records Group");
if (groupName.Equals("Team admin"))
{
addNodesToTreeView(TeamAdminRecordsTypesTreeView, createNewNodes, selectedRecordsTypeGUID);
addNodesToTreeView(TeamAdminRecordsTypesFilter, forFilteringNodes, selectedRecordsTypeGUID);
}
if (groupName.Equals("Our work"))
{
addNodesToTreeView(OurWorkRecordsTypesTreeView, createNewNodes, selectedRecordsTypeGUID);
addNodesToTreeView(OurWorkRecordsTypesFilter, forFilteringNodes, selectedRecordsTypeGUID);
}
if (groupName.Equals("Council-wide business"))
{
addNodesToTreeView(CouncilWideRecordsTypesTreeView, createNewNodes, selectedRecordsTypeGUID);
addNodesToTreeView(CouncilWideRecordsTypesFilter, forFilteringNodes, selectedRecordsTypeGUID);
}
}
catch (Exception exception)
{
WBUtils.logMessage("The error message was: " + exception.Message);
}
}
}
}
if (!IsPostBack)
{
List <String> ascendingDescendingOptions = new List <String>();
ascendingDescendingOptions.Add("Ascending");
ascendingDescendingOptions.Add("Descending");
AscendingDescendingChoice.DataSource = ascendingDescendingOptions;
AscendingDescendingChoice.DataBind();
List <String> statusOptions = new List <String>();
statusOptions.Add("Open");
statusOptions.Add("Closed");
statusOptions.Add("Deleted");
statusOptions.Add("Any");
StatusFilter.DataSource = statusOptions;
StatusFilter.DataBind();
List <String> involvementOptions = new List <String>();
involvementOptions.Add(FILTER_INVOLVEMENT__OWNS);
involvementOptions.Add(FILTER_INVOLVEMENT__INVOLVED);
involvementOptions.Add(FILTER_INVOLVEMENT__VISITING);
InvolvementFilter.DataSource = involvementOptions;
InvolvementFilter.DataBind();
if (!LoadDefaultView())
{
SetSortColumn(WBColumn.WorkBoxDateLastModified);
GridViewSortDirection = SortDirection.Descending;
SelectedViewStyle = VIEW_STYLE__ICONS;
StatusCheckBox.Checked = false;
RecordsTypeCheckBox.Checked = true;
LastModifiedCheckBox.Checked = true;
DateCreatedCheckBox.Checked = true;
StatusFilter.WBxSafeSetSelectedValue("Any");
}
WBLogging.Debug("Not in post back so setting guid value to be: " + SelectedRecordsTypeGUID);
RefreshBoundData();
}
}
private void RefreshBoundData()
{
if (IsPostBack)
{
ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "TriggerUpdateFunction", "aspPanelHasUpdated();", true);
}
WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
WBTaxonomy teams = WBTaxonomy.GetTeams(recordsTypes);
WBQuery query = new WBQuery();
query.AddViewColumn(WBColumn.Title);
query.AddViewColumn(WBColumn.WorkBoxURL);
// query.AddViewColumn(WBColumn.FunctionalArea);
//query.AddViewColumn(WBColumn.ReferenceDate);
//query.AddViewColumn(WBColumn.ReferenceID);
//query.AddViewColumn(WBColumn.SeriesTag);
// query.AddViewColumn(WBColumn.InvolvedTeams);
//List<String> orderByColumnOptions = new List<String>();
//orderByColumnOptions.Add("Title");
checkSortState();
if (sortColumn != null)
{
query.OrderBy(sortColumn, ascending);
}
SelectedWorkBoxes.Columns.Clear();
SelectedWorkBoxes.Columns.Add(WBUtils.StatusIconTemplateField("24"));
SelectedWorkBoxes.Columns.Add(WBUtils.HyperLinkField(WBColumn.Title, WBColumn.WorkBoxURL, sortColumn, ascending, ""));
OrderBy.Items.Clear();
addColumnAsOption(OrderBy, WBColumn.Title);
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.FunctionalArea, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.SeriesTag, sortColumn, ascending));
query.AddViewColumn(WBColumn.WorkBoxStatus);
if (StatusCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxStatus, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxStatus);
}
string statusFilter = SelectedWorkBoxStatusFilter;
if (statusFilter != "Any")
{
query.AddEqualsFilter(WBColumn.WorkBoxStatus, statusFilter);
}
query.AddViewColumn(WBColumn.RecordsType);
if (RecordsTypeCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.RecordsType);
}
if (LastModifiedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateLastModified);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastModified, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateLastModified);
}
if (LastVisitedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateLastVisited);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastVisited, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateLastVisited);
}
if (DateCreatedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateCreated);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateCreated, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateCreated);
}
if (ReferenceDateCheckBox.Checked)
{
query.AddViewColumn(WBColumn.ReferenceDate);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.ReferenceDate);
}
if (ReferenceIDCheckBox.Checked)
{
query.AddViewColumn(WBColumn.ReferenceID);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.ReferenceID);
}
query.AddViewColumn(WBColumn.OwningTeam);
if (OwningTeamCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.OwningTeam);
}
query.AddViewColumn(WBColumn.InvolvedTeams);
if (InvolvedTeamsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedTeams, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.InvolvedTeams);
}
query.AddViewColumn(WBColumn.VisitingTeams);
if (VisitingTeamsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.VisitingTeams, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.VisitingTeams);
}
query.AddViewColumn(WBColumn.InvolvedIndividuals);
if (InvolvedIndividualsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedIndividuals, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.InvolvedIndividuals);
}
query.AddViewColumn(WBColumn.VisitingIndividuals);
if (VisitingIndividualsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.VisitingIndividuals, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.VisitingIndividuals);
}
//OrderBy.DataSource = orderByColumnOptions;
//OrderBy.DataBind();
OrderBy.WBxSafeSetSelectedValue(ViewState["SortExpression"].WBxToString());
WBRecordsType recordsType = null;
WBTeam team = WBTeam.GetFromTeamSite(teams, SPContext.Current.Web);
WBLogging.Generic.Unexpected("SelectedInvolvementFilter = " + SelectedInvolvementFilter);
if (team != null)
{
switch (SelectedInvolvementFilter)
{
case FILTER_INVOLVEMENT__OWNS:
{
WBLogging.Debug("Adding a filter for OwningTeam");
query.AddEqualsFilter(WBColumn.OwningTeam, team);
break;
}
case FILTER_INVOLVEMENT__INVOLVED:
{
WBLogging.Debug("Adding a filter for InvolvedTeams");
query.AddEqualsFilter(WBColumn.InvolvedTeams, team);
break;
}
case FILTER_INVOLVEMENT__VISITING:
{
WBLogging.Debug("Adding a filter for VisitingTeams");
query.AddEqualsFilter(WBColumn.VisitingTeams, team);
break;
}
}
}
if (SelectedRecordsTypeGUID != "")
{
recordsType = recordsTypes.GetRecordsType(new Guid(SelectedRecordsTypeGUID));
}
if (recordsType != null)
{
String recordsTypePath = recordsType.FullPath;
//recordsTypePath = recordsTypePath.Substring(1, recordsTypePath.Length - 1);
recordsTypePath = recordsTypePath.Replace("/", " / ");
RecordsTypeSelected.Text = recordsTypePath;
RecordsTypeDescription.Text = recordsType.Description;
WBQueryClause recordsTypeClause = new WBQueryClause(WBColumn.RecordsType, WBQueryClause.Comparators.Equals, recordsType);
recordsTypeClause.UseDescendants = false;
query.AddClause(recordsTypeClause);
}
else
{
RecordsTypeSelected.Text = "No records type selected";
RecordsTypeDescription.Text = "";
}
String cachedDetailsListUrl = WBFarm.Local.OpenWorkBoxesCachedDetailsListUrl;
// OK so this is a general 'recent' query
using (SPWeb cacheWeb = SPContext.Current.Site.OpenWeb(cachedDetailsListUrl))
{
SPList cacheList = cacheWeb.GetList(cachedDetailsListUrl);
SPListItemCollection items = cacheList.WBxGetItems(SPContext.Current.Site, query);
if (items.Count > 0)
{
StringBuilder html = new StringBuilder();
foreach (SPListItem item in items)
{
String status = item.WBxGetAsString(WBColumn.WorkBoxStatus);
html.Append("<div class='wbf-icons-view-icon-panel'><div class='wbf-icons-view-icon'><a href='");
html.Append(item.WBxGetAsString(WBColumn.WorkBoxURL)).Append("'>").Append("<img src='").Append(WBUtils.StatusIconImageURL(status, "64")).Append("' alt='Work box icon for: ").Append(item.WBxGetAsString(WBColumn.Title).Replace('\'', ' ')).Append("' />").Append("</a></div><div class='wbf-icons-view-label'><a href='");
html.Append(item.WBxGetAsString(WBColumn.WorkBoxURL)).Append("'>").Append(item.WBxGetAsString(WBColumn.Title)).Append("</a></div></div>\n\n");
}
IconViewLiteral.Text = html.ToString();
}
else
{
IconViewLiteral.Text = "<p>" + NoWorkBoxesText + "</p>";
}
DataTable dataTable = cacheList.WBxGetDataTable(SPContext.Current.Site, query);
SelectedWorkBoxes.DataSource = dataTable;
SelectedWorkBoxes.DataBind();
}
}
public WBRecord DeclareNewRecord(WBTaskFeedback feedback, String callingUserLogin, WBDocument document, WBRecord recordToReplace, String replacingAction, WBItem extraMetadata)
{
WBTerm functionalArea = document.FunctionalArea[0];
WBRecordsType recordsType = document.RecordsType;
string fullClassPath = WBUtils.NormalisePath(functionalArea.Name + "/" + recordsType.FullPath);
WBLogging.RecordsTypes.HighLevel("Declaring a document to the library with path: " + fullClassPath);
string datePath = "NO DATE SET";
string dateForName = "YYYY-MM-DD";
string oldDateFormat = "YYYYMMDD-";
// If nothing else we'll use the time now (which will be roughly the date / time declared as the date for the naming convention:
DateTime referenceDate = DateTime.Now;
if (document.HasReferenceDate && recordsType.DocumentReferenceDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN)
{
referenceDate = document.ReferenceDate;
}
else
{
document.ReferenceDate = referenceDate;
}
int year = referenceDate.Year;
int month = referenceDate.Month;
if (month >= 4)
{
datePath = String.Format("{0}-{1}", year.ToString("D4"), (year + 1).ToString("D4"));
}
else
{
datePath = String.Format("{0}-{1}", (year - 1).ToString("D4"), year.ToString("D4"));
}
dateForName = String.Format("{0}-{1}-{2}",
referenceDate.Year.ToString("D4"),
referenceDate.Month.ToString("D2"),
referenceDate.Day.ToString("D2"));
oldDateFormat = String.Format("{0}{1}{2}-",
referenceDate.Year.ToString("D4"),
referenceDate.Month.ToString("D2"),
referenceDate.Day.ToString("D2"));
string fullFilingPath = String.Join("/", recordsType.FilingPathForDocument(document).ToArray());
WBLogging.Debug("The original filename is set as: " + document.OriginalFilename);
String extension = Path.GetExtension(document.OriginalFilename);
String filename = WBUtils.RemoveDisallowedCharactersFromFilename(document.OriginalFilename);
String titleForFilename = document[WBColumn.Title].WBxToString();
String referenceID = document.ReferenceID;
// We don't want to use a title that is too long:
if (String.IsNullOrEmpty(titleForFilename) || titleForFilename.Length > 50)
{
titleForFilename = "";
}
if (String.IsNullOrEmpty(titleForFilename) && String.IsNullOrEmpty(referenceID))
{
titleForFilename = Path.GetFileNameWithoutExtension(filename);
// Let's now remove the old date format if the date is the same as the one
// that is going to be used for the new date format:
titleForFilename = titleForFilename.Replace(oldDateFormat, "");
}
if (String.IsNullOrEmpty(referenceID))
{
filename = "(" + dateForName + ") " + titleForFilename + extension;
}
else
{
if (String.IsNullOrEmpty(titleForFilename))
{
filename = "(" + dateForName + ") " + referenceID + extension;
}
else
{
filename = "(" + dateForName + ") " + referenceID + " - " + titleForFilename + extension;
}
}
filename = WBUtils.RemoveDisallowedCharactersFromFilename(filename);
SPContentType classFolderType = null;
SPContentType filePartFolderType = null;
try
{
classFolderType = ProtectedMasterLibrary.Site.RootWeb.ContentTypes[WBRecordsType.RECORDS_LIBRARY__CLASS_FOLDER_CONTENT_TYPE];
filePartFolderType = ProtectedMasterLibrary.Site.RootWeb.ContentTypes[WBRecordsType.RECORDS_LIBRARY__FILE_PART_FOLDER_CONTENT_TYPE];
}
catch (Exception exception)
{
WBLogging.RecordsTypes.Unexpected("Couldn't find the class and/or file part folder content types.");
throw new Exception("Couldn't find the class and/or file part folder content types.", exception);
}
if (classFolderType == null)
{
classFolderType = ProtectedMasterLibrary.Site.RootWeb.ContentTypes[WBRecordsType.RECORDS_LIBRARY__FALL_BACK_FOLDER_CONTENT_TYPE];
}
if (filePartFolderType == null)
{
filePartFolderType = ProtectedMasterLibrary.Site.RootWeb.ContentTypes[WBRecordsType.RECORDS_LIBRARY__FALL_BACK_FOLDER_CONTENT_TYPE];
}
SPFolder protectedLibraryRootFolder = ProtectedMasterLibrary.List.RootFolder;
protectedLibraryRootFolder.WBxGetOrCreateFolderPath(fullClassPath, classFolderType.Id);
SPFolder actualDestinationFolder = protectedLibraryRootFolder.WBxGetOrCreateFolderPath(fullFilingPath, filePartFolderType.Id);
/*
* // This next bit is all because we've been having problems when new folders had to be created:
* if (actualDestinationFolder == null)
* {
* WBLogging.RecordsTypes.HighLevel("We have to create part of the folder path: " + fullFilingPath);
* actualDestinationFolder = protectedLibraryRootFolder.WBxGetOrCreateFolderPath(fullFilingPath, filePartFolderType.Id);
*
* WBLogging.RecordsTypes.HighLevel("Now we're going to add a dummy first file:");
*
* MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes("Please ignore this file."));
* SPFile dummyFile = actualDestinationFolder.Files.Add("FirstFile.txt", memoryStream);
*
* WBLogging.RecordsTypes.HighLevel("Now we're going to try to update the file");
* try
* {
* dummyFile.Item.Update();
* }
* catch (Exception e)
* {
* WBLogging.RecordsTypes.Unexpected("And exception did occur while updating the dummy item", e);
* }
*
* memoryStream.Dispose();
*
* WBLogging.RecordsTypes.HighLevel("Now re-opening the whole ProtectedMasterLibrary object");
*
* ProtectedMasterLibrary.ReOpen();
*
* WBLogging.RecordsTypes.HighLevel("Have re-opened the whole ProtectedMasterLibrary object - now re-getting the SPFolder:");
*
* protectedLibraryRootFolder = ProtectedMasterLibrary.List.RootFolder;
* actualDestinationFolder = protectedLibraryRootFolder.WBxGetFolderPath(fullFilingPath);
* }
*/
if (ProtectedMasterLibrary.Web.WBxFileExists(actualDestinationFolder, filename))
{
filename = ProtectedMasterLibrary.Web.WBxMakeFilenameUnique(actualDestinationFolder, filename);
}
SPFile uploadedFile = actualDestinationFolder.Files.Add(filename, document.OpenBinaryStream());
SPListItem uploadedItem = uploadedFile.Item;
if (extraMetadata == null)
{
extraMetadata = new WBItem();
}
if (!extraMetadata.IsUsingColumn(WBColumn.DatePublished))
{
extraMetadata[WBColumn.DatePublished] = DateTime.Now;
}
if (!extraMetadata.IsUsingColumn(WBColumn.PublishedBy) && SPContext.Current != null)
{
extraMetadata[WBColumn.PublishedBy] = SPContext.Current.Web.CurrentUser;
}
WBRecord newRecord = new WBRecord(this, uploadedItem, uploadedItem.ID.ToString(), document, extraMetadata);
if (feedback != null)
{
String urlToFolder = newRecord.ProtectedMasterRecord.AbsoluteURL.Replace(newRecord.Name, "");
feedback.AddFeedback("Uploaded file to protected, master records library");
feedback.AddFeedback("Master record: <a href='" + newRecord.ProtectedMasterRecord.AbsoluteURL + "' target='_blank'>" + newRecord.ProtectedMasterRecord.AbsoluteURL + "</a>");
feedback.AddFeedback("In folder: <a href='" + urlToFolder + "' target='_blank'>" + urlToFolder + "</a>");
}
if (recordToReplace != null)
{
// OK so actually we need to do the replacement actions with elevated priviledges:
//bool digestOK = SPContext.Current.Web.ValidateFormDigest();
//if (digestOK)
//{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (WBRecordsManager manager = new WBRecordsManager(callingUserLogin))
{
WBRecord elevatedRecordToReplace = manager.Libraries.GetRecordByID(recordToReplace.RecordID);
if (replacingAction == WBPublishingProcess.REPLACE_ACTION__ARCHIVE_FROM_IZZI)
{
elevatedRecordToReplace.LiveOrArchived = WBColumn.LIVE_OR_ARCHIVED__ARCHIVED;
elevatedRecordToReplace.RecordSeriesStatus = WBColumn.RECORD_SERIES_STATUS__ARCHIVED;
}
else
{
elevatedRecordToReplace.RecordSeriesStatus = WBColumn.RECORD_SERIES_STATUS__RETIRED;
}
elevatedRecordToReplace.Update(callingUserLogin, "Record was " + elevatedRecordToReplace.RecordSeriesStatus + " because it was replaced through publishing process");
if (feedback != null)
{
feedback.AddFeedback("Archived record being replaced");
}
WBLogging.Debug("WBRecordsLibraries.DeclareNewRecord(): Archived the record being replaced Record ID = " + recordToReplace.RecordID);
}
});
newRecord.ReplacesRecordID = recordToReplace.RecordID;
newRecord.RecordSeriesID = recordToReplace.RecordSeriesID;
newRecord.RecordSeriesIssue = "" + (recordToReplace.RecordSeriesIssue.WBxToInt() + 1);
newRecord.RecordSeriesStatus = WBColumn.RECORD_SERIES_STATUS__LATEST;
}
else
{
newRecord.ReplacesRecordID = null;
newRecord.RecordSeriesID = newRecord.RecordID;
newRecord.RecordSeriesIssue = "1";
newRecord.RecordSeriesStatus = WBColumn.RECORD_SERIES_STATUS__LATEST;
}
newRecord.LiveOrArchived = WBColumn.LIVE_OR_ARCHIVED__LIVE;
newRecord.UpdateMasterAndCreateCopies(feedback, callingUserLogin);
bool beforeForDocument = document.Web.AllowUnsafeUpdates;
document.Web.AllowUnsafeUpdates = true;
// And now just copy back to the original document any metadata changes:
document.MaybeCopyColumns(newRecord.Metadata, WBRecord.DefaultColumnsToCopy);
// And let's make sure that the original document is using the work box document content type:
if (document.IsSPListItem)
{
SPContentType workBoxDocumentType = document.Item.ParentList.ContentTypes[WBFarm.Local.WorkBoxDocumentContentTypeName];
if (workBoxDocumentType != null)
{
document.Item["ContentTypeId"] = workBoxDocumentType.Id;
}
}
document.Update();
// uploadedItem.Update();
// uploadedFile.Update();
bool beforeForUploadedFile = uploadedFile.Web.AllowUnsafeUpdates;
uploadedFile.Web.AllowUnsafeUpdates = true;
if (uploadedFile.CheckOutType != SPFile.SPCheckOutType.None)
{
uploadedFile.WBxCheckInAs("Declared new major version of record.", SPCheckinType.MajorCheckIn, callingUserLogin);
}
else
{
WBLogging.Migration.Verbose("There was no need to check in file: " + uploadedFile.Name);
}
uploadedFile.Web.AllowUnsafeUpdates = beforeForUploadedFile;
document.Web.AllowUnsafeUpdates = beforeForDocument;
return(newRecord);
}
private void RefreshBrowsableTreeView()
{
switch (SelectedView)
{
case VIEW_BY_RECORDS_TYPE:
{
// TreeViewTermCollection collection = new TreeViewTermCollection();
// collection.Add(new TreeViewTerm(recordsTypesTaxonomy.TermSet));
// BrowsableTreeView.DataSource = collection;
// BrowsableTreeView.DataBind();
foreach (Term term in recordsTypesTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypesTaxonomy, term);
if (recordsType.AllowDocumentRecords)
{
BrowsableTreeView.Nodes.Add(AddRecordsTypeBranch(null, recordsType));
}
}
}
break;
}
case VIEW_BY_FUNCTION_THEN_TYPE:
{
//WBTaxonomy functionalAreasTaxonomy = WBTaxonomy.GetFunctionalAreas(recordsTypesTaxonomy);
//BrowsableTreeView.DataSource = null;
foreach (Term term in functionalAreaTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
BrowsableTreeView.Nodes.Add(AddFunctionBranch(term));
}
}
break;
}
case VIEW_BY_SUBJECT:
{
foreach (Term term in subjectTagsTaxonomy.TermSet.Terms)
{
if (term.IsAvailableForTagging)
{
BrowsableTreeView.Nodes.Add(AddSubjectBranch(term));
}
}
break;
}
case VIEW_BY_FOLDER_PATH:
{
String recordsLibraryURL = WBFarm.Local.ProtectedRecordsLibraryUrl;
List <String> pathParts = new List <String>(SelectedNodePath.Split('/'));
using (SPSite site = new SPSite(recordsLibraryURL))
{
using (SPWeb web = site.OpenWeb())
{
SPList recordsLibrary = web.GetList(recordsLibraryURL); //"Documents"]; //farm.RecordsCenterRecordsLibraryName];
Dictionary <String, TreeNode> newNodes = new Dictionary <String, TreeNode>();
foreach (SPFolder functionFolder in recordsLibrary.RootFolder.SubFolders)
{
//Term foundTerm = functionalAreaTaxonomy.GetSelectedTermByPath(functionFolder.Name);
//if (foundTerm != null && foundTerm.IsAvailableForTagging)
if (functionFolder.Name != "Forms")
{
TreeNode newNode = AddFunctionFolderBranch(functionFolder, pathParts);
newNodes.Add(newNode.Text, newNode);
}
}
List <String> allNames = new List <String>(newNodes.Keys);
allNames.Sort();
foreach (String name in allNames)
{
BrowsableTreeView.Nodes.Add(newNodes[name]);
}
}
}
break;
}
}
}
private string addWorkBoxesForRecordsClass(WBTaxonomy recordsTypes, TermCollection recordsTypesTerms)
{
if (recordsTypesTerms.Count == 0)
{
return("");
}
string finalHtml = "";
bool containsWorkBoxesForMe = false;
foreach (Term recordsTypeTerm in recordsTypesTerms)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypes, recordsTypeTerm);
string html = "";
string workBoxesHtml = "";
containsWorkBoxesForMe = false;
html = "<tr><td colspan=\"5\" class=\"wbf-records-type\">\n" + recordsType.Name + "</td></tr>\n";
// html += "<li class=\"wbf-records-type\">" + recordsType.Name;
// html += "\n";
string workBoxCollectionURL = recordsType.WorkBoxCollectionUrl;
WBUtils.logMessage("The work box collection url = " + workBoxCollectionURL);
if (workBoxCollectionURL != "")
{
bool originalAccessDeniedCatchValue = SPSecurity.CatchAccessDeniedException;
SPSecurity.CatchAccessDeniedException = false;
try
{
using (WBCollection collection = new WBCollection(workBoxCollectionURL))
{
SPListItemCollection workBoxResults = collection.QueryFilteredBy(recordsType, WorkBox.WORK_BOX_STATUS__OPEN, false);
if (workBoxResults != null && workBoxResults.Count > 0)
{
containsWorkBoxesForMe = true;
workBoxesHtml = addWorkBoxResults(collection, workBoxResults);
}
}
}
catch (UnauthorizedAccessException e)
{
WBUtils.logMessage("UnauthorizedAccessException thrown for user trying to access: " + workBoxCollectionURL + " Exception was: " + e.Message);
// Let's just hide this for the moment as the user doesn't have access to here anyway.
workBoxesHtml = "";
}
catch (Exception e)
{
workBoxesHtml = "<i>Exception occured when trying to get results from the work box collection at: " + workBoxCollectionURL + " Exception was: " + e.Message + "</i>";
}
finally
{
SPSecurity.CatchAccessDeniedException = originalAccessDeniedCatchValue;
}
}
if (containsWorkBoxesForMe || ShowAllRecordsTypes)
{
html += workBoxesHtml;
//html += "</li>\n";
finalHtml += html;
}
}
if (finalHtml != "" || ShowAllRecordsTypes)
{
// finalHtml = "<ul class=\"wbf-my-work-boxes-list wbf-records-types\">\n" + finalHtml + "</ul>\n";
}
return(finalHtml);
}
protected void Page_Load(object sender, EventArgs e)
{
WBLogging.Generic.Verbose("In Page_Load for the public doc metadata dialog");
// Creating the taxonomy objects for later use:
recordsTypeTaxonomy = WBTaxonomy.GetRecordsTypes(WorkBox.Site);
teamsTaxonomy = WBTaxonomy.GetTeams(recordsTypeTaxonomy);
seriesTagsTaxonomy = WBTaxonomy.GetSeriesTags(recordsTypeTaxonomy);
subjectTagsTaxonomy = WBTaxonomy.GetSubjectTags(recordsTypeTaxonomy);
functionalAreasTaxonomy = WBTaxonomy.GetFunctionalAreas(recordsTypeTaxonomy);
// If this is the initial call to the page then we need to load the basic details of the document we're publishing out:
if (!IsPostBack)
{
ListGUID.Value = Request.QueryString["ListGUID"];
ItemID.Value = Request.QueryString["ItemID"];
// The following variable has its name due to a strange compliation error with the name 'DestinationType'
TheDestinationType.Value = Request.QueryString["DestinationType"];
DestinationURL.Value = Request.QueryString["DestinationURL"];
DestinationTitle.Text = Request.QueryString["DestinationTitle"] + " (" + Request.QueryString["DestinationType"] + ")";
WBLogging.Generic.Verbose("DestinationType = " + TheDestinationType.Value);
WBLogging.Generic.Verbose("DestinationURL = " + DestinationURL.Value);
}
// Now do a check that we do at this stage have the basic details of the document:
if (ListGUID.Value == null || ListGUID.Value == "")
{
errorMessage += "ListGUID hasn't been set. ";
}
if (ItemID.Value == null || ItemID.Value == "")
{
errorMessage += "ItemID hasn't been set. ";
}
if (TheDestinationType.Value == null || TheDestinationType.Value == "")
{
errorMessage += "DestinationType hasn't been set. ";
}
if (errorMessage.Length > 0)
{
ErrorMessageLabel.Text = errorMessage;
return;
}
// Let's clear out all of the error messages text fields:
ErrorMessageLabel.Text = "";
RecordsTypeFieldMessage.Text = "";
FunctionalAreaFieldMessage.Text = "";
ProtectiveZoneMessage.Text = "";
ReferenceIDMessage.Text = "";
ReferenceDateMessage.Text = "";
SeriesTagFieldMessage.Text = "";
ScanDateMessage.Text = "";
OwningTeamFieldMessage.Text = "";
InvolvedTeamsFieldMessage.Text = "";
//OK so we have the basic identity information for the document being published out so let's get the document item:
Guid sourceListGuid = new Guid(ListGUID.Value);
SPDocumentLibrary sourceDocLib = (SPDocumentLibrary)WorkBox.Web.Lists[sourceListGuid];
sourceDocAsItem = sourceDocLib.GetItemById(int.Parse(ItemID.Value));
sourceFile = sourceDocAsItem.File;
generatingFilename = WorkBox.RecordsType.GeneratePublishOutFilenames;
// Now, if this is the first time we might need to load up the default metadata values for the document:
if (!IsPostBack)
{
WorkBox.Web.AllowUnsafeUpdates = true;
WorkBox.ApplyPublishOutDefaults(sourceDocAsItem);
WorkBox.Web.AllowUnsafeUpdates = false;
// Let's now re-load the item as it's name may have changed:
sourceDocAsItem = null;
sourceDocAsItem = sourceDocLib.GetItemById(int.Parse(ItemID.Value));
sourceFile = sourceDocAsItem.File;
pageRenderingRequired = true;
}
else
{
WBLogging.Debug("Setting the subject tags: " + SubjectTagsField.Text);
sourceDocAsItem.WBxSetMultiTermColumn(WorkBox.COLUMN_NAME__SUBJECT_TAGS, SubjectTagsField.Text);
// If this is a post back - then let's check if the records type has been modified:
if (NewRecordsTypeUIControlValue.Value != "")
{
WBLogging.Generic.Unexpected("The returned value was: " + NewRecordsTypeUIControlValue.Value);
WBRecordsType oldRecordsType = sourceDocAsItem.WBxGetSingleTermColumn <WBRecordsType>(recordsTypeTaxonomy, WorkBox.COLUMN_NAME__RECORDS_TYPE);
WBRecordsType newRecordsType = new WBRecordsType(recordsTypeTaxonomy, NewRecordsTypeUIControlValue.Value);
RecordsTypeUIControlValue.Value = NewRecordsTypeUIControlValue.Value;
RecordsType.Text = newRecordsType.Name;
pageRenderingRequired = true;
// These are now being done in CaptureAsDocument()
// sourceDocAsItem.WBxSetSingleTermColumn(WorkBox.COLUMN_NAME__RECORDS_TYPE, NewRecordsTypeUIControlValue.Value);
// sourceDocAsItem.WBxSet(WBColumn.Title, this.TitleField.Text);
// This is now being done in CaptureAsDocument()
// WorkBox.GenerateFilename(newRecordsType, sourceDocAsItem);
// If either the old or new records type have an uneditable functional area, then we'll update it to the new default area.
if (!oldRecordsType.IsFunctionalAreaEditable || !newRecordsType.IsFunctionalAreaEditable)
{
WBLogging.Debug("Setting the functional area as it's not editable: " + newRecordsType.DefaultFunctionalAreaUIControlValue);
this.FunctionalAreaField.Text = newRecordsType.DefaultFunctionalAreaUIControlValue;
sourceDocAsItem.WBxSetMultiTermColumn(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, newRecordsType.DefaultFunctionalAreaUIControlValue);
}
/* This is now being done in CaptureAsDocument()
* else
* {
* WBLogging.Debug("Saving the current functional area selection: " + this.FunctionalAreaField.Text);
* sourceDocAsItem.WBxSetMultiTermColumn(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, this.FunctionalAreaField.Text);
* }
*/
WBDocument document = CaptureAsDocument(sourceDocAsItem, newRecordsType);
document.Update();
// Let's now re-load the item as it's name may have changed:
sourceDocAsItem = null;
sourceDocAsItem = sourceDocLib.GetItemById(int.Parse(ItemID.Value));
sourceFile = sourceDocAsItem.File;
}
else
{
// Otherwise we are in a normal post back call.
pageRenderingRequired = false;
}
}
// Now load up some of the basic details:
documentRecordsType = sourceDocAsItem.WBxGetSingleTermColumn <WBRecordsType>(recordsTypeTaxonomy, WorkBox.COLUMN_NAME__RECORDS_TYPE);
destinationType = TheDestinationType.Value;
// Which of the metadata fields are being used in the form (or will need to be processed in any postback) :
showReferenceID = documentRecordsType.DocumentReferenceIDRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showReferenceDate = documentRecordsType.DocumentReferenceDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showSubjectTags = true; // documentRecordsType.DocumentSubjectTagsRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showSeriesTag = documentRecordsType.DocumentSeriesTagRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showScanDate = documentRecordsType.DocumentScanDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
if (pageRenderingRequired)
{
renderPage();
}
}
protected void Page_Load(object sender, EventArgs e)
{
webPart = this.Parent as ViewRecordsLibraryWebPart;
recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
teamsTaxonomy = WBTaxonomy.GetTeams(recordsTypesTaxonomy);
functionalAreaTaxonomy = WBTaxonomy.GetFunctionalAreas(recordsTypesTaxonomy);
subjectTagsTaxonomy = WBTaxonomy.GetSubjectTags(recordsTypesTaxonomy);
if (!IsPostBack)
{
// ViewSelector.DataSource = LibraryViews;
// ViewSelector.DataBind();
ProtectiveZoneFilterOptions = WBRecordsType.getProtectiveZones();
ProtectiveZoneFilterOptions.Insert(0, "");
FilterByProtectiveZone.DataSource = ProtectiveZoneFilterOptions;
FilterByProtectiveZone.DataBind();
string selectedView = webPart.RecordsLibraryView;
if (!String.IsNullOrEmpty(Request.QueryString["FolderPath"]))
{
selectedView = VIEW_BY_FOLDER_PATH;
SelectedNodePath = Request.QueryString["FolderPath"];
}
if (String.IsNullOrEmpty(selectedView))
{
selectedView = VIEW_BY_RECORDS_TYPE;
}
SelectedViewTitle.Text = selectedView;
SelectedView = selectedView;
}
RefreshBrowsableTreeView();
ShowResults.AllowSorting = true;
ShowResults.Sorting += new GridViewSortEventHandler(ShowResults_Sorting);
ShowResults.AllowPaging = true;
ShowResults.PageIndexChanging += new GridViewPageEventHandler(ShowResults_PageIndexChanging);
ShowResults.PagerSettings.Mode = PagerButtons.Numeric;
ShowResults.PagerSettings.Position = PagerPosition.Bottom;
ShowResults.PagerSettings.PageButtonCount = 50;
ShowResults.PagerSettings.Visible = true;
ShowResults.PageSize = 50;
// this odd statement is required in order to get the pagination to work with an SPGridView!
ShowResults.PagerTemplate = null;
if (SelectedView == VIEW_BY_FOLDER_PATH)
{
RefreshBoundData();
}
}
protected void Page_Load(object sender, EventArgs e)
{
SPWeb web = SPContext.Current.Web;
SPSite site = SPContext.Current.Site;
string selectedToggleID = Request.Params["selectedToggleID"];
string selectedRecordsTypeGUID = Request.Params["recordsTypeGUID"];
WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
string teamGUIDString = "";
Team = WBTeam.GetFromTeamSite(SPContext.Current);
if (Team == null)
{
return;
}
teamGUIDString = WBExtensions.WBxToString(Team.Id);
string recordsTypesListUrl = Team.RecordsTypesListUrl;
if (recordsTypesListUrl == null || recordsTypesListUrl == "")
{
// recordsTypesListUrl = web.Url + "/Lists/Configure%20Teams%20Records%20Classes";
NotSetupText = "(<i>The team has no records types list setup yet.</i>)";
return;
}
using (SPWeb configWeb = site.OpenWeb(recordsTypesListUrl))
{
ConfigurationList = configWeb.GetList(recordsTypesListUrl);
if (ConfigurationList != null)
{
if (!ConfigurationList.Fields.ContainsField("Records Class"))
{
ConfigurationList = null;
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " has no 'Records Class' column.</i>)";
}
}
else
{
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " was not set up correctly or does not exist.</i>)";
}
if (ConfigurationList != null)
{
RecordsClasses = new List <Hashtable>();
int classCount = 0;
int classTotal = 0;
foreach (SPListItem item in ConfigurationList.Items)
{
try
{
string groupName = item.WBxGetColumnAsString("Records Group");
if (groupName.Equals(RecordsGroup))
{
classTotal++;
}
}
catch (Exception exception)
{
WBUtils.logMessage("The error message when counting the classes was: " + exception.StackTrace);
}
}
WBUtils.logMessage("The class count was found to be: " + classCount);
foreach (SPListItem item in ConfigurationList.Items)
{
try
{
string groupName = item.WBxGetColumnAsString("Records Group");
if (groupName.Equals(RecordsGroup))
{
classCount++;
Hashtable recordsClassDetails = new Hashtable();
List <Hashtable> recordsTypes = new List <Hashtable>();
WBRecordsType recordsClass = new WBRecordsType(recordsTypesTaxonomy, WBExtensions.WBxGetColumnAsString(item, "Records Class"));
string workBoxCollectionURL = recordsClass.WorkBoxCollectionUrl;
string viewPagerelativeURL = WBExtensions.WBxGetColumnAsString(item, "ViewPageRelativeURL");
string recordsTypeGUID = recordsClass.Id.WBxToString();
string uniqueToggleID = string.Format("WBF_Grouping_{0}_Child_{1}", AdditionalCSSStyle, classCount);
string viewURL = "#";
if (viewPagerelativeURL != "")
{
viewURL = string.Format("{0}{1}?selectedToggleID={2}&recordsTypeGUID={3}&workBoxCollectionURL={4}",
SPContext.Current.Web.ServerRelativeUrl,
viewPagerelativeURL,
uniqueToggleID,
recordsTypeGUID,
Uri.EscapeDataString(workBoxCollectionURL));
}
/*
* string viewURL = string.Format("{0}{1}?selectedToggleID={2}",
* SPContext.Current.Web.ServerRelativeUrl,
* viewPagerelativeURL,
* uniqueToggleID);
*/
string selectedRecordsClass = "";
if (uniqueToggleID.Equals(selectedToggleID))
{
selectedRecordsClass = " wbf-selected-records-class";
}
string selectedRecordsType = "";
if (recordsTypeGUID.Equals(selectedRecordsTypeGUID))
{
selectedRecordsType = " wbf-selected-records-type";
}
WBUtils.logMessage("Class count and class total: " + classCount + " " + classTotal);
if (classCount == classTotal)
{
selectedRecordsClass += " wbf-last-class";
}
recordsClassDetails[LINK_TEXT] = recordsClass.Name;
recordsClassDetails[LINK_URL] = viewURL;
recordsClassDetails[ON_CLICK_COMMAND] = "javascript: $('#" + uniqueToggleID + "').toggle(200);";
recordsClassDetails[UNIQUE_TOGGLE_ID] = uniqueToggleID;
recordsClassDetails[SELECTED_CLASS_CSS_STYLE] = selectedRecordsClass;
recordsClassDetails[SELECTED_TYPE_CSS_STYLE] = selectedRecordsType;
int typeCount = 0;
int typeTotal = recordsClass.Term.Terms.Count;
Dictionary <String, Hashtable> allRecordsTypeDetails = new Dictionary <String, Hashtable>();
foreach (Term term in recordsClass.Term.Terms)
{
typeCount++;
Hashtable recordsTypeDetails = new Hashtable();
WBRecordsType recordsType = new WBRecordsType(recordsTypesTaxonomy, term);
// If the term has been marked as unavailable then it shouldn't be liseted here.
if (!recordsType.IsAvailableForTagging || !recordsType.AllowWorkBoxRecords)
{
continue;
}
recordsTypeGUID = recordsType.Id.ToString();
selectedRecordsType = "";
if (recordsTypeGUID.Equals(selectedRecordsTypeGUID))
{
selectedRecordsType = " wbf-selected-records-type";
}
viewURL = string.Format("{0}{1}?selectedToggleID={2}&recordsTypeGUID={3}&workBoxCollectionURL={4}",
SPContext.Current.Web.ServerRelativeUrl,
viewPagerelativeURL,
uniqueToggleID,
recordsTypeGUID,
Uri.EscapeDataString(workBoxCollectionURL));
if (typeCount == typeTotal)
{
selectedRecordsType += " wbf-last-type";
}
recordsTypeDetails[LINK_TEXT] = recordsType.Name;
recordsTypeDetails[LINK_URL] = viewURL;
recordsTypeDetails[ON_CLICK_COMMAND] = "";
recordsTypeDetails[SELECTED_TYPE_CSS_STYLE] = selectedRecordsType;
allRecordsTypeDetails.Add(recordsType.Name, recordsTypeDetails);
}
List <String> allNames = new List <String>(allRecordsTypeDetails.Keys);
allNames.Sort();
foreach (String name in allNames)
{
recordsTypes.Add(allRecordsTypeDetails[name]);
}
/* Not showing the create link here any more.
* string createNewURL = "";
* string createNewText = "";
* WBCollection collection = null;
*
* if (workBoxCollectionURL != null && workBoxCollectionURL != "")
* {
* collection = new WBCollection(workBoxCollectionURL);
* if (collection.CanAnyoneCreate == true)
* {
* createNewURL = collection.GetUrlForNewDialog(Team);
* createNewText = collection.CreateNewWorkBoxText;
* }
* }
* else
* {
* createNewText = "";
* createNewURL = "";
* workBoxCollectionURL = "";
* }
*
* if (createNewText != "")
* {
* Hashtable createLink = new Hashtable();
*
* createLink[LINK_TEXT] = createNewText;
* createLink[LINK_URL] = "#";
* createLink[ON_CLICK_COMMAND] = "javascript: WorkBoxFramework_commandAction('" + createNewURL + "', 600, 500);";
* createLink[ADDITIONAL_TYPE_CSS_STYLE] = "wbf-create-new-link";
*
* recordsTypes.Add(createLink);
* }
*/
recordsClassDetails[RECORDS_TYPES] = recordsTypes;
RecordsClasses.Add(recordsClassDetails);
}
}
catch (Exception exception)
{
RecordsClasses.Add(makeErrorRecordsClassEntry());
WBUtils.logMessage("The error message was: " + exception.StackTrace);
}
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
SPWeb web = SPContext.Current.Web;
SPSite site = SPContext.Current.Site;
WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
string teamGUIDString = "";
Team = WBTeam.GetFromTeamSite(SPContext.Current);
if (Team == null)
{
return;
}
teamGUIDString = WBExtensions.WBxToString(Team.Id);
string recordsTypesListUrl = Team.RecordsTypesListUrl;
if (recordsTypesListUrl == null || recordsTypesListUrl == "")
{
//recordsTypesListUrl = web.Url + "/Lists/Configure%20Teams%20Records%20Classes";
NotSetupText = "(<i>The team has no records types list setup yet.</i>)";
return;
}
string selectedRecordsTypeGUID = Request.QueryString["recordsTypeGUID"];
using (SPWeb configWeb = site.OpenWeb(recordsTypesListUrl))
{
ConfigurationList = configWeb.GetList(recordsTypesListUrl);
if (ConfigurationList != null)
{
if (!ConfigurationList.Fields.ContainsField("Records Class"))
{
ConfigurationList = null;
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " has no 'Records Class' column.</i>)";
}
}
else
{
NotSetupText = "(<i>The configuration list " + recordsTypesListUrl + " was not set up correctly or does not exist.</i>)";
}
if (ConfigurationList != null)
{
RecordsTypeTreeView.Nodes.Clear();
foreach (SPListItem item in ConfigurationList.Items)
{
try
{
string groupName = item.WBxGetColumnAsString("Records Group");
if (groupName.Equals(RecordsGroup))
{
WBRecordsType recordsClass = new WBRecordsType(recordsTypesTaxonomy, WBExtensions.WBxGetColumnAsString(item, "Records Class"));
TreeNode node = createNodes(recordsClass);
RecordsTypeTreeView.Nodes.Add(node);
RecordsTypeTreeView.CollapseAll();
expandByRecordsTypeGUID(RecordsTypeTreeView.Nodes, selectedRecordsTypeGUID);
}
}
catch (Exception exception)
{
WBUtils.logMessage("The error message was: " + exception.Message);
}
}
}
}
}
public WBRecordsTypeTreeNode(WBTerm functionalArea, WBRecordsType recordsType, SPFolder folder)
: base(folder)
{
FunctionalArea = functionalArea;
RecordsType = recordsType;
}
public IHierarchicalEnumerable GetChildren()
{
if (_children == null)
{
_children = new TreeViewLocationCollection();
switch (_type)
{
case LOCATION_TYPE__FUNCTIONAL_AREA: {
WBLogging.Debug("In GetChildren() for type Functional Area");
WBTaxonomy recordsTypes = _manager.RecordsTypesTaxonomy;
TermCollection terms = recordsTypes.TermSet.Terms;
foreach (Term childTerm in terms)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypes, childTerm);
bool protectiveZoneOK = true;
//if (!String.IsNullOrEmpty(_minimumProtectiveZone))
//{
// protectiveZoneOK = (recordsType.IsZoneAtLeastMinimum(_minimumProtectiveZone));
// }
if (recordsType.BranchCanHaveDocuments() && recordsType.IsRelevantToFunctionalArea(_functionalArea) && protectiveZoneOK)
{
TreeViewLocation newLocation = new TreeViewLocation(this, _manager, _mode, _minimumProtectiveZone, _functionalArea, recordsType);
// If we're looking for existing records then we'll only add this location if it has a real folder existing underneath it:
if (_mode == VIEW_MODE__NEW || newLocation._folder != null)
{
_children.Add(newLocation);
}
}
else
{
WBLogging.Debug("In GetChildren() excluded " + recordsType.Name + " because " + recordsType.BranchCanHaveDocuments() + " && " + protectiveZoneOK);
}
}
break;
}
case LOCATION_TYPE__RECORDS_TYPE: {
WBLogging.Debug("In GetChildren() for type Records Type");
WBTaxonomy recordsTypes = _manager.RecordsTypesTaxonomy;
TermCollection terms = _recordsType.Term.Terms;
if (terms.Count > 0)
{
foreach (Term childTerm in terms)
{
WBRecordsType recordsType = new WBRecordsType(recordsTypes, childTerm);
bool protectiveZoneOK = true;
if (!String.IsNullOrEmpty(_minimumProtectiveZone))
{
protectiveZoneOK = (recordsType.IsZoneAtLeastMinimum(_minimumProtectiveZone));
}
if (recordsType.BranchCanHaveDocuments() && recordsType.IsRelevantToFunctionalArea(_functionalArea) && protectiveZoneOK)
{
TreeViewLocation newLocation = new TreeViewLocation(this, _manager, _mode, _minimumProtectiveZone, _functionalArea, recordsType);
// If we're looking for existing records then we'll only add this location if it has a real folder existing underneath it:
if (_mode == VIEW_MODE__NEW || newLocation._folder != null)
{
_children.Add(newLocation);
}
}
}
}
else
{
if (_mode != VIEW_MODE__NEW)
{
// WBLogging.Debug("In view mode replace switching to folders part of tree");
string fullClassPath = WBUtils.NormalisePath(Path);
// WBLogging.Debug("Looking for starting folder = " + fullClassPath);
SPFolder protectedLibraryRootFolder = _manager.Libraries.ProtectedMasterLibrary.List.RootFolder;
// WBLogging.Debug("Got library root folder");
SPFolder recordsTypeFolder = protectedLibraryRootFolder.WBxGetFolderPath(fullClassPath);
// WBLogging.Debug("Got records type folder - definitely changed .. " + recordsTypeFolder);
if (recordsTypeFolder != null)
{
foreach (SPFolder child in recordsTypeFolder.SubFolders)
{
_children.Add(new TreeViewLocation(this, _manager, _mode, _minimumProtectiveZone, child));
}
}
else
{
WBLogging.Debug("The master library doesn't have a folder with path: " + fullClassPath);
}
// WBLogging.Debug("Added children folders");
}
}
break;
}
case LOCATION_TYPE__FOLDER: {
WBLogging.Debug("In GetChildren() for type Folder");
if (_folder.SubFolders.Count > 0)
{
foreach (SPFolder child in _folder.SubFolders)
{
_children.Add(new TreeViewLocation(this, _manager, _mode, _minimumProtectiveZone, child));
}
}
else
{
if (_mode == VIEW_MODE__REPLACE)
{
SPListItemCollection items = GetItemsRecursive(_folder);
foreach (SPListItem item in items)
{
if (ItemCanBePicked(item))
{
_children.Add(new TreeViewLocation(this, _manager, _mode, _minimumProtectiveZone, new WBDocument(_manager.Libraries.ProtectedMasterLibrary, item)));
}
}
}
}
break;
}
case LOCATION_TYPE__DOCUMENT: {
WBLogging.Debug("In GetChildren() for type Document");
break;
}
}
}
return(_children);
}
private Hashtable checkMetadataState()
{
Hashtable metadataProblems = new Hashtable();
if (OwningTeamField.Text.Equals(""))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__OWNING_TEAM, "You must enter the owning team.");
}
if (InvolvedTeamsField.Text.Equals(""))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__INVOLVED_TEAMS, "You must enter at least one involved team.");
}
if (RecordsType.Text.Equals(""))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__RECORDS_TYPE, "You must enter a records type for this document.");
}
else
{
// So here we'll load up the actual records type so that we can check what other metadata is required:
documentRecordsType = new WBRecordsType(recordsTypeTaxonomy, RecordsTypeUIControlValue.Value);
if (documentRecordsType != null)
{
if (!documentRecordsType.AllowDocumentRecords)
{
metadataProblems.Add(WorkBox.COLUMN_NAME__RECORDS_TYPE, "You cannot publish documents of this records type. Please choose another.");
}
if (documentRecordsType.IsFunctionalAreaEditable)
{
if (FunctionalAreaField.Text == "")
{
metadataProblems.Add(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, "The functional area must be set.");
}
}
bool userCanPublishToPublic = false;
SPGroup publishersGroup = WorkBox.OwningTeam.PublishersGroup(SPContext.Current.Site);
if (publishersGroup != null)
{
if (publishersGroup.ContainsCurrentUser)
{
userCanPublishToPublic = true;
}
}
if (userCanPublishToPublic)
{
if (!documentRecordsType.IsZoneAtLeastMinimum(ProtectiveZone.Text))
{
if (ProtectiveZone.Text == WBRecordsType.PROTECTIVE_ZONE__PUBLIC_EXTRANET)
{
metadataProblems.Add(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE, "You can only publish to the public extranet zone if the records type has that zone explicitly set. This records type has the minimum zone set as: " + documentRecordsType.DocumentMinimumProtectiveZone);
}
else
{
metadataProblems.Add(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE, "The selected protective zone does not meet the minimum requirement for this records type of: " + documentRecordsType.DocumentMinimumProtectiveZone);
}
}
}
else
{
if (ProtectiveZone.Text != WBRecordsType.PROTECTIVE_ZONE__PROTECTED)
{
metadataProblems.Add(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE, "In this work box you only have permissions to publish to the internal records library.");
}
}
if (documentRecordsType.IsDocumentReferenceIDRequired)
{
if (ReferenceID.Text.Equals(""))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__REFERENCE_ID, "You must enter a reference ID for this records type.");
}
}
if (documentRecordsType.IsDocumentReferenceDateRequired)
{
if (ReferenceDate.IsDateEmpty)
{
metadataProblems.Add(WorkBox.COLUMN_NAME__REFERENCE_DATE, "You must enter a reference date for this records type.");
}
}
if (documentRecordsType.IsDocumentSeriesTagRequired)
{
if (SeriesTagDropDownList.SelectedValue.Equals(""))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__SERIES_TAG, "You must select a series tag for this records type.");
}
}
if (documentRecordsType.IsDocumentScanDateRequired)
{
if (ScanDate.IsDateEmpty)
{
metadataProblems.Add(WorkBox.COLUMN_NAME__SCAN_DATE, "You must enter a scan date for this records type.");
}
}
}
else
{
metadataProblems.Add(WorkBox.COLUMN_NAME__RECORDS_TYPE, "Could not find this records type.");
}
}
if (destinationType.Equals(WorkBox.PUBLISHING_OUT_DESTINATION_TYPE__PUBLIC_WEB_SITE) &&
!ProtectiveZone.SelectedValue.Equals(WBRecordsType.PROTECTIVE_ZONE__PUBLIC))
{
if (!metadataProblems.ContainsKey(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE))
{
metadataProblems.Add(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE, "Only documents marked as 'Public' can be published to the Public Web Site");
}
}
return(metadataProblems);
}
protected WBDocument CaptureAsDocument(SPListItem sourceDocAsItem, WBRecordsType documentRecordsType)
{
WBDocument document = new WBDocument(WorkBox, sourceDocAsItem);
// Which of the metadata fields are being used by the active records type?
showReferenceID = documentRecordsType.DocumentReferenceIDRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showReferenceDate = documentRecordsType.DocumentReferenceDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showSubjectTags = true; // documentRecordsType.DocumentSubjectTagsRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showSeriesTag = documentRecordsType.DocumentSeriesTagRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
showScanDate = documentRecordsType.DocumentScanDateRequirement != WBRecordsType.METADATA_REQUIREMENT__HIDDEN;
//document.Name =
// if (!generatingFilename)
// {
// sourceDocAsItem["Name"] = NameField.Text;
// }
document.Title = TitleField.Text;
//sourceDocAsItem["Title"] = TitleField.Text;
if (documentRecordsType.IsFunctionalAreaEditable)
{
document[WBColumn.FunctionalArea] = FunctionalAreaField.Text;
sourceDocAsItem.WBxSetMultiTermColumn(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, FunctionalAreaField.Text);
}
//document.FunctionalArea = sourceDocAsItem.WBxGetMultiTermColumn<WBTerm>(functionalAreasTaxonomy, WBColumn.FunctionalArea.DisplayName);
String protectiveZone = ProtectiveZone.SelectedValue;
document.ProtectiveZone = protectiveZone;
//sourceDocAsItem.WBxSetColumnAsString(WorkBox.COLUMN_NAME__PROTECTIVE_ZONE, protectiveZone);
// Now to save the current value of the Records Type field:
document[WBColumn.RecordsType] = RecordsTypeUIControlValue.Value;
//sourceDocAsItem.WBxSetSingleTermColumn(WorkBox.COLUMN_NAME__RECORDS_TYPE, RecordsTypeUIControlValue.Value);
if (showSubjectTags)
{
WBLogging.Debug("Setting subject tags to be: " + SubjectTagsField.Text);
document[WBColumn.SubjectTags] = SubjectTagsField.Text;
}
else
{
WBLogging.Debug("NOT !!! Setting subject tags to be: " + SubjectTagsField.Text);
}
if (showReferenceID)
{
document.ReferenceID = ReferenceID.Text;
//sourceDocAsItem.WBxSetColumnAsString(WorkBox.COLUMN_NAME__REFERENCE_ID, ReferenceID.Text);
}
if (showReferenceDate)
{
document.ReferenceDate = ReferenceDate.SelectedDate;
// sourceDocAsItem[WorkBox.COLUMN_NAME__REFERENCE_DATE] = ReferenceDate.SelectedDate;
}
if (showSeriesTag)
{
document[WBColumn.SeriesTag] = SeriesTagDropDownList.SelectedValue;
//sourceDocAsItem.WBxSetSingleTermColumn(WorkBox.COLUMN_NAME__SERIES_TAG, SeriesTagDropDownList.SelectedValue);
}
if (showScanDate)
{
document.ScanDate = ScanDate.SelectedDate;
//sourceDocAsItem[WorkBox.COLUMN_NAME__SCAN_DATE] = ScanDate.SelectedDate;
}
//sourceDocAsItem.WBxSetSingleTermColumn(WorkBox.COLUMN_NAME__OWNING_TEAM, OwningTeamField.Text);
//sourceDocAsItem.WBxSetMultiTermColumn(WorkBox.COLUMN_NAME__INVOLVED_TEAMS, InvolvedTeamsField.Text);
document[WBColumn.OwningTeam] = OwningTeamField.Text;
document[WBColumn.InvolvedTeams] = InvolvedTeamsField.Text;
document.CheckOwningTeamIsAlsoInvolved();
if (String.IsNullOrEmpty(document.OriginalFilename))
{
document.OriginalFilename = sourceDocAsItem.Name;
}
WorkBox.GenerateFilename(documentRecordsType, sourceDocAsItem);
/*
* if (WorkBox.RecordsType.GeneratePublishOutFilenames)
* {
* WorkBox.GenerateFilename(documentRecordsType, sourceDocAsItem);
* }
*
* sourceDocAsItem.Update();
*/
return(document);
}
private void RefreshBoundData()
{
if (SelectedNodePath != "")
{
SelectedRecordsType.Text = SelectedNodePath.Replace("Records Types/", "").Replace("/", " / ");
WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
WBTaxonomy teams = WBTaxonomy.GetTeams(recordsTypes);
WBRecordsType recordsType = recordsTypes.GetSelectedRecordsType(SelectedNodePath);
SelectedRecordsTypeDescription.Text = recordsType.Description;
WBTeam team = WBTeam.GetFromTeamSite(teams, SPContext.Current.Web);
WBFarm farm = WBFarm.Local;
using (WBCollection collection = new WBCollection(recordsType.WorkBoxCollectionUrl))
{
// using (SPWeb web = site.OpenWeb())
// {
WBQuery query = new WBQuery();
WBQueryClause recordsTypeClause = new WBQueryClause(WBColumn.RecordsType, WBQueryClause.Comparators.Equals, recordsType);
recordsTypeClause.UseDescendants = true;
query.AddClause(recordsTypeClause);
if (team != null)
{
query.AddEqualsFilter(WBColumn.InvolvedTeams, team);
}
string statusFilter = Request.QueryString["Status"];
if (statusFilter != null && statusFilter != "")
{
query.AddEqualsFilter(WBColumn.WorkBoxStatus, statusFilter);
}
query.AddViewColumn(WBColumn.Title);
query.AddViewColumn(WBColumn.WorkBoxURL);
query.AddViewColumn(WBColumn.OwningTeam);
// query.AddViewColumn(WBColumn.FunctionalArea);
query.AddViewColumn(WBColumn.ReferenceDate);
query.AddViewColumn(WBColumn.ReferenceID);
query.AddViewColumn(WBColumn.SeriesTag);
// query.AddViewColumn(WBColumn.InvolvedTeams);
query.AddViewColumn(WBColumn.WorkBoxStatus);
if (sortColumn != null)
{
query.OrderBy(sortColumn, ascending);
}
DataTable dataTable = collection.Query(query);
ShowResults.DataSource = dataTable;
ShowResults.Columns.Clear();
ShowResults.Columns.Add(WBUtils.FixedIconTemplateField(WorkBox.ICON_16_IMAGE_URL, WBColumn.WorkBoxURL));
ShowResults.Columns.Add(WBUtils.HyperLinkField(WBColumn.Title, WBColumn.WorkBoxURL, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.FunctionalArea, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.SeriesTag, sortColumn, ascending));
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedTeams, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxStatus, sortColumn, ascending));
ShowResults.DataBind();
// }
}
}
else
{
WBUtils.logMessage("SelectedNodePath was empty");
}
}
private void RefreshBoundData()
{
if (SelectedNodePath != "")
{
SPGroup rmManagersGroup = SPContext.Current.Web.WBxGetGroupOrNull(WBFarm.Local.RecordsManagersGroupName);
if (rmManagersGroup != null)
{
if (rmManagersGroup.ContainsCurrentUser)
{
currentUserIsRecordsManager = true;
WBLogging.Debug("Set the current user as being a records manager.");
}
else
{
WBLogging.Debug("The current user is not a part of the RM Managers group called: " + WBFarm.Local.RecordsManagersGroupName);
}
}
else
{
WBLogging.Debug("Could not find the RM Managers group called: " + WBFarm.Local.RecordsManagersGroupName);
}
SelectedRecordsType.Text = SelectedNodePath.Replace("Records Types/", "").Replace("/", " / ");
WBRecordsType recordsType = null;
WBTerm functionalArea = null;
WBTerm subjectTag = null;
switch (SelectedView)
{
case VIEW_BY_RECORDS_TYPE:
{
recordsType = recordsTypesTaxonomy.GetSelectedRecordsType(SelectedNodePath);
SelectedRecordsTypeDescription.Text = recordsType.Description;
break;
}
case VIEW_BY_FUNCTION_THEN_TYPE:
{
string[] parts = SelectedNodePath.Split('/');
if (parts.Length < 3)
{
break;
}
string functionPath = parts[0];
List <String> partsList = new List <String>(parts);
partsList.RemoveAt(0);
string recordsTypePath = String.Join("/", partsList.ToArray());
Term functionalAreaTerm = functionalAreaTaxonomy.GetSelectedTermByPath(functionPath);
if (functionalAreaTerm != null)
{
functionalArea = new WBTerm(functionalAreaTaxonomy, functionalAreaTerm);
}
recordsType = recordsTypesTaxonomy.GetSelectedRecordsType(recordsTypePath);
SelectedRecordsTypeDescription.Text = recordsType.Description;
break;
}
case VIEW_BY_SUBJECT:
{
Term subjectTagsTerm = subjectTagsTaxonomy.GetSelectedTermByPath(SelectedNodePath);
if (subjectTagsTerm != null)
{
subjectTag = new WBTerm(subjectTagsTaxonomy, subjectTagsTerm);
SelectedRecordsTypeDescription.Text = subjectTag.Description;
}
if (subjectTag == null)
{
WBLogging.Generic.Verbose("Did not find subject with path: " + SelectedNodePath);
return;
}
break;
}
case VIEW_BY_FOLDER_PATH:
{
string[] parts = SelectedNodePath.Split('/');
if (parts.Length < 3)
{
break;
}
string functionPath = parts[0];
List <String> recordsTypePartsList = new List <String>();
recordsTypePartsList.Add(parts[1]);
recordsTypePartsList.Add(parts[2]);
string recordsTypePath = String.Join("/", recordsTypePartsList.ToArray());
Term functionalAreaTerm = functionalAreaTaxonomy.GetSelectedTermByPath(functionPath);
if (functionalAreaTerm != null)
{
functionalArea = new WBTerm(functionalAreaTaxonomy, functionalAreaTerm);
}
recordsType = recordsTypesTaxonomy.GetSelectedRecordsType(recordsTypePath);
SelectedRecordsTypeDescription.Text = recordsType.Description;
break;
}
default: return;
}
WBTeam team = WBTeam.GetFromTeamSite(teamsTaxonomy, SPContext.Current.Web);
WBFarm farm = WBFarm.Local;
using (SPSite site = new SPSite(farm.ProtectedRecordsLibraryUrl))
{
using (SPWeb web = site.OpenWeb())
{
WBQuery query = new WBQuery();
if (recordsType == null && functionalArea == null)
{
query.LogicallyCannotHaveResults = true;
}
else
{
if (SelectedView == VIEW_BY_FUNCTION_THEN_TYPE || SelectedView == VIEW_BY_FOLDER_PATH)
{
WBLogging.Generic.Unexpected("Setting FilterByFolderPath = " + SelectedNodePath);
query.FilterByFolderPath = SelectedNodePath;
}
else
{
if (recordsType != null)
{
WBQueryClause recordsTypeClause = new WBQueryClause(WBColumn.RecordsType, WBQueryClause.Comparators.Equals, recordsType);
recordsTypeClause.UseDescendants = true;
query.AddClause(recordsTypeClause);
}
if (functionalArea != null)
{
WBQueryClause functionalAreaClause = new WBQueryClause(WBColumn.FunctionalArea, WBQueryClause.Comparators.Equals, functionalArea);
functionalAreaClause.UseDescendants = true;
query.AddClause(functionalAreaClause);
}
}
query.AddClause(new WBQueryClause(WBColumn.ContentType, WBQueryClause.Comparators.Equals, farm.WorkBoxRecordContentTypeName));
if (subjectTag != null)
{
WBQueryClause subjectTagClause = new WBQueryClause(WBColumn.SubjectTags, WBQueryClause.Comparators.Equals, subjectTag);
subjectTagClause.UseDescendants = false;
query.AddClause(subjectTagClause);
}
if (team != null)
{
query.AddEqualsFilter(WBColumn.InvolvedTeams, team);
}
if (!String.IsNullOrEmpty(webPart.FilterByProtectiveZone))
{
query.AddEqualsFilter(WBColumn.ProtectiveZone, webPart.FilterByProtectiveZone);
}
}
showFilters = true;
string statusFilter = SelectedLiveOrArchivedStatusFilter;
if (statusFilter == null || statusFilter == "")
{
statusFilter = "All"; // WBColumn.LIVE_OR_ARCHIVED__LIVE;
}
if (statusFilter != "All")
{
query.AddEqualsFilter(WBColumn.LiveOrArchived, statusFilter);
}
FilterLiveStatus.CssClass = "wbf-unselected-filter";
FilterArchivedStatus.CssClass = "wbf-unselected-filter";
FilterAllStatus.CssClass = "wbf-unselected-filter";
if (statusFilter == WBColumn.LIVE_OR_ARCHIVED__LIVE)
{
FilterLiveStatus.CssClass = "wbf-selected-filter";
}
if (statusFilter == WBColumn.LIVE_OR_ARCHIVED__ARCHIVED)
{
FilterArchivedStatus.CssClass = "wbf-selected-filter";
}
if (statusFilter == "All")
{
FilterAllStatus.CssClass = "wbf-selected-filter";
}
query.AddViewColumn(WBColumn.Name);
query.AddViewColumn(WBColumn.Title);
query.AddViewColumn(WBColumn.TitleOrName);
query.AddViewColumn(WBColumn.FileSize);
query.AddViewColumn(WBColumn.FileTypeIcon);
query.AddViewColumn(WBColumn.FileType);
query.AddViewColumn(WBColumn.DisplayFileSize);
query.AddViewColumn(WBColumn.EncodedAbsoluteURL);
query.AddViewColumn(WBColumn.FunctionalArea);
query.AddViewColumn(WBColumn.OwningTeam);
query.AddViewColumn(WBColumn.ReferenceDate);
query.AddViewColumn(WBColumn.ReferenceID);
query.AddViewColumn(WBColumn.SeriesTag);
query.AddViewColumn(WBColumn.ProtectiveZone);
query.AddViewColumn(WBColumn.RecordID);
query.AddViewColumn(WBColumn.LiveOrArchived);
if (SelectedView != VIEW_BY_SUBJECT)
{
query.AddViewColumn(WBColumn.SubjectTags);
}
else
{
query.AddViewColumn(WBColumn.RecordsType);
}
if (sortColumn != null)
{
query.OrderBy(sortColumn, ascending);
}
SPList recordsLibrary = web.GetList(farm.ProtectedRecordsLibraryUrl); //"Documents"]; //farm.RecordsCenterRecordsLibraryName];
DataTable dataTable = recordsLibrary.WBxGetDataTable(site, query);
ShowResults.DataSource = dataTable;
ShowResults.Columns.Clear();
ShowResults.Columns.Add(WBUtils.DynamicIconTemplateField(WBColumn.FileTypeIcon, WBColumn.EncodedAbsoluteURL));
ShowResults.Columns.Add(WBUtils.HyperLinkField(WBColumn.TitleOrName, WBColumn.EncodedAbsoluteURL, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.FileType, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.DisplayFileSize, sortColumn, ascending));
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.FunctionalArea, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, sortColumn, ascending));
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, sortColumn, ascending));
//ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.SeriesTag, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.ProtectiveZone, sortColumn, ascending));
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.LiveOrArchived, sortColumn, ascending));
if (SelectedView != VIEW_BY_SUBJECT)
{
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.SubjectTags, sortColumn, ascending));
}
else
{
ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, sortColumn, ascending));
}
if (this.currentUserIsRecordsManager)
{
List <WBColumn> valueColumns = new List <WBColumn>();
valueColumns.Add(WBColumn.RecordID);
String formatString = SPContext.Current.Web.Url + "/_layouts/WorkBoxFramework/UpdateRecordsMetadata.aspx?RecordID={0}";
formatString = "<a href=\"javascript: WorkBoxFramework_commandAction('" + formatString + "', 800, 600); \">(edit metadata)</a>";
ShowResults.Columns.Add(WBUtils.FormatStringTemplateField(formatString, valueColumns));
WBLogging.Debug("Added the (edit metadata) show column.");
}
else
{
WBLogging.Debug("Did not add the (edit metadata) show column.");
}
ShowResults.DataBind();
}
}
}
else
{
WBUtils.logMessage("SelectedNodePath was empty");
}
}
