Example #1
0
        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);
        }
Example #2
0
        protected override void CreateChildControls()
        {
            WBTaxonomy teams = WBTaxonomy.GetTeams(SPContext.Current.Site);

            team = WBTeam.GetFromTeamSite(teams, SPContext.Current);

            Literal literal = new Literal();
            string  html    = "";

            //html += tempStyling();

            WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);

            TermCollection recordsClassesTerms = recordsTypes.TermSet.Terms;

            html += addWorkBoxesForRecordsClasses(recordsTypes, recordsClassesTerms);


            literal.Text = html;
            this.Controls.Add(literal);
        }
Example #3
0
        protected void Page_Load(object sender, EventArgs e)
        {
            team = WBTeam.GetFromTeamSite(SPContext.Current);

            if (team == null)
            {
                ErrorText.Text       = "You should only be using this form when on a team site.";
                ChangeButton.Enabled = false;
                return;
            }

            if (!team.IsCurrentUserTeamManagerOrSystemAdmin())
            {
                ErrorText.Text       = "Only team the team manager can change the team manager.";
                ChangeButton.Enabled = false;
                return;
            }

            if (!IsPostBack)
            {
                TeamName.Text = team.Name;
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            team = WBTeam.GetFromTeamSite(SPContext.Current);

            if (team == null)
            {
                AreYouSureText.Text = "You should only be using this form when on a team site.";
                AddButton.Enabled   = false;
                return;
            }

            if (!team.IsCurrentUserTeamOwnerOrSystemAdmin())
            {
                AreYouSureText.Text = "Only team owners can add members to a team.";
                AddButton.Enabled   = false;
                return;
            }

            if (!IsPostBack)
            {
                AreYouSureText.Text = "Are you sure you want to add all of the managers reports (all staff below manager) as members of this team?";
            }
        }
Example #5
0
        protected void Page_Load(object sender, EventArgs e)
        {
            teams = WBTaxonomy.GetTeams(SPContext.Current.Site);
            team  = WBTeam.GetFromTeamSite(teams, SPContext.Current);

            if (team == null)
            {
                ErrorText.Text = "You do not appear to be viewing this form while on a team site.";
                return;
            }


            if (!team.IsCurrentUserTeamOwnerOrSystemAdmin())
            {
                ErrorText.Text = "Only team owners or system admin can invite individuals to a team.";
                return;
            }


            if (!IsPostBack)
            {
                TeamName.Text = team.Name;

                InviteAsMember.Checked = true;
                InviteAsOwner.Checked  = false;

                SendInviteEmail.Checked = true;
                SendAsOne.Checked       = true;
                CCToYou.Checked         = true;

                EmailSubject.Text = WBFarm.Local.InviteToTeamDefaultEmailSubject;
                EmailBody.Text    = WBFarm.Local.InviteToTeamDefaultEmailBody;

                IndividualsToInviteControl.Focus();
            }
        }
Example #6
0
        protected void Page_Load(object sender, EventArgs e)
        {
            string relatedWorkBoxUrl     = "";
            string recordsTypeGUIDString = "";

            // Set the reference date control to match the locally set locale:
            ReferenceDate.LocaleId = SPContext.Current.Web.Locale.LCID;

            recordsTypes    = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
            teams           = WBTaxonomy.GetTeams(recordsTypes);
            seriesTags      = WBTaxonomy.GetSeriesTags(recordsTypes);
            functionalAreas = WBTaxonomy.GetFunctionalAreas(recordsTypes);

            if (!IsPostBack)
            {
                WorkBoxCollectionUrl.Value = Request.QueryString["workBoxCollectionUrl"];
                pageRenderingRequired      = true;

                recordsTypeGUIDString = Request.QueryString["recordsTypeGUID"];
                RecordsTypeGUID.Value = recordsTypeGUIDString;

                if (recordsTypeGUIDString != "")
                {
                    workBoxRecordsType = recordsTypes.GetRecordsType(new Guid(recordsTypeGUIDString));
                }
                else
                {
                    WBLogging.Generic.Unexpected("The records type GUID appears to be blank in initial call to page!");
                }


                // Now to setup some default intiail values:

                ReferenceDate.SelectedDate = DateTime.Now;

                functionalAreaFieldIsEditable = workBoxRecordsType.IsFunctionalAreaEditable;

                string owningTeamGuidString = Request.QueryString["owningTeamGUID"];
                WBTeam owningTeam           = null;

                if (owningTeamGuidString != null && !owningTeamGuidString.Equals(""))
                {
                    owningTeam = teams.GetTeam(new Guid(owningTeamGuidString));

                    OwningTeamField.Text           = owningTeam.Name; //  UIControlValue;
                    OwningTeamUIControlValue.Value = owningTeam.UIControlValue;

                    InvolvedTeamsField.Text = owningTeam.UIControlValue;
                }

                relatedWorkBoxUrl       = Request.QueryString["relatedWorkBoxURL"];
                RelatedWorkBoxUrl.Value = relatedWorkBoxUrl;
                RelationType.Value      = Request.QueryString["relationType"];
                if (relatedWorkBoxUrl != null && relatedWorkBoxUrl != "")
                {
                    relatedWorkBox = new WorkBox(relatedWorkBoxUrl);

                    ReferenceID.Text = relatedWorkBox.ReferenceID;

                    WBTerm seriesTag = relatedWorkBox.SeriesTag(seriesTags);
                    if (seriesTag != null)
                    {
                        seriesTagInitialValue = seriesTag.UIControlValue;
                    }

                    owningTeam                     = relatedWorkBox.OwningTeam;
                    OwningTeamField.Text           = owningTeam.Name; //  UIControlValue;
                    OwningTeamUIControlValue.Value = owningTeam.UIControlValue;
                    InvolvedTeamsField.Text        = relatedWorkBox.InvolvedTeams.UIControlValue;
                }


                // Now let's setup the initial value for the functional area:
                if (functionalAreaFieldIsEditable)
                {
                    functionalAreaInitialValue = workBoxRecordsType.DefaultFunctionalAreaUIControlValue;

                    if (functionalAreaInitialValue == null || functionalAreaInitialValue == "")
                    {
                        if (owningTeam != null)
                        {
                            functionalAreaInitialValue = owningTeam.FunctionalArea(functionalAreas).UIControlValue;
                        }
                    }
                }
                else
                {
                    functionalAreaInitialValue = workBoxRecordsType.DefaultFunctionalAreaUIControlValue;
                }
            }
            else
            {
                WBUtils.logMessage("In the postback with workBoxCollectionUrl = " + WorkBoxCollectionUrl.Value);
                pageRenderingRequired = false;

                relatedWorkBoxUrl = RelatedWorkBoxUrl.Value;

                recordsTypeGUIDString = RecordsTypeGUID.Value;

                if (recordsTypeGUIDString != "")
                {
                    workBoxRecordsType = recordsTypes.GetRecordsType(new Guid(recordsTypeGUIDString));
                }
                else
                {
                    WBLogging.Generic.Unexpected("The records type GUID appears to be blank in postback!");
                }
            }



            if (pageRenderingRequired)
            {
                renderPage();
            }
        }
Example #7
0
        protected void createNewButton_OnClick(object sender, EventArgs e)
        {
            Hashtable metadataProblems = checkMetadataState();

            if (metadataProblems.Count > 0)
            {
                RecordsTypeFieldMessage.Text = metadataProblems[WorkBox.COLUMN_NAME__RECORDS_TYPE].WBxToString();

                FunctionalAreaFieldMessage.Text = metadataProblems[WorkBox.COLUMN_NAME__FUNCTIONAL_AREA].WBxToString();

                WorkBoxShortTitleMessage.Text = metadataProblems[WorkBox.COLUMN_NAME__WORK_BOX_SHORT_TITLE].WBxToString();

                ReferenceIDMessage.Text    = metadataProblems[WorkBox.COLUMN_NAME__REFERENCE_ID].WBxToString();;
                ReferenceDateMessage.Text  = metadataProblems[WorkBox.COLUMN_NAME__REFERENCE_DATE].WBxToString();;
                SeriesTagFieldMessage.Text = metadataProblems[WorkBox.COLUMN_NAME__SERIES_TAG].WBxToString();

                OwningTeamFieldMessage.Text    = metadataProblems[WorkBox.COLUMN_NAME__OWNING_TEAM].WBxToString();
                InvolvedTeamsFieldMessage.Text = metadataProblems[WorkBox.COLUMN_NAME__INVOLVED_TEAMS].WBxToString();

                pageRenderingRequired = true;
            }
            else
            {
                pageRenderingRequired = false;
            }

            // The event should only be processed if there is no other need to render the page again
            if (pageRenderingRequired)
            {
                renderPage();
            }
            else
            {
                WBCollection collection = new WBCollection(WorkBoxCollectionUrl.Value);

                collection.Web.AllowUnsafeUpdates = true;

                WBUtils.logMessage("OK so we've set to allow unsafe updates of the WorkBoxCollectionWeb");

                string selectedWorkBoxTemplateValue = WorkBoxTemplateID.Value;
                if (selectedWorkBoxTemplateValue == "")
                {
                    selectedWorkBoxTemplateValue = WorkBoxTemplates.SelectedValue;
                }

                int templateID = Convert.ToInt32(selectedWorkBoxTemplateValue);

                WBTemplate template = collection.GetTypeByID(templateID);


                WBTeam owningTeam = new WBTeam(teams, OwningTeamUIControlValue.Value);
                WBTermCollection <WBTeam> involvedTeams = new WBTermCollection <WBTeam>(teams, InvolvedTeamsField.Text);

                Hashtable extraValues = null;
                extraValues = new Hashtable();

                if (ReferenceID.Text != "")
                {
                    extraValues.Add(WorkBox.COLUMN_NAME__REFERENCE_ID, ReferenceID.Text);
                }

                if (!ReferenceDate.IsDateEmpty)
                {
                    extraValues.Add(WorkBox.COLUMN_NAME__REFERENCE_DATE, ReferenceDate.SelectedDate);
                }

                if (SeriesTagDropDownList.SelectedValue != "")
                {
                    extraValues.Add(WorkBox.COLUMN_NAME__SERIES_TAG, SeriesTagDropDownList.SelectedValue);
                }

                if (functionalAreaFieldIsEditable)
                {
                    extraValues.Add(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, FunctionalAreaField.Text);
                }
                else
                {
                    extraValues.Add(WorkBox.COLUMN_NAME__FUNCTIONAL_AREA, workBoxRecordsType.DefaultFunctionalArea(functionalAreas).UIControlValue);
                }

                WBLogging.Generic.Unexpected("Owning team has values: " + owningTeam.Name + " " + owningTeam.Id);
                WorkBox newWorkBox = collection.RequestNewWorkBox(WorkBoxShortTitle.Text, "", template, owningTeam, involvedTeams, extraValues);

                if (newWorkBox == null)
                {
                    string pageTitle = Uri.EscapeDataString("Failed to create new work box");
                    string pageText  = Uri.EscapeDataString("Your request to create a new work box was not successful.");

                    string redirectUrl = "WorkBoxFramework/GenericOKPage.aspx";
                    string queryString = "pageTitle=" + pageTitle + "&pageText=" + pageText;

                    SPUtility.Redirect(redirectUrl, SPRedirectFlags.RelativeToLayoutsPage, Context, queryString);
                }


                collection.Web.AllowUnsafeUpdates = false;

                using (SPLongOperation longOperation = new SPLongOperation(this.Page))
                {
                    longOperation.LeadingHTML  = "Creating your new work box.";
                    longOperation.TrailingHTML = "Please wait while the work box is being created.";

                    longOperation.Begin();


                    newWorkBox.Open("Requested via NewWorkBox.aspx.");

                    if (relatedWorkBox != null)
                    {
                        switch (RelationType.Value)
                        {
                        case WorkBox.RELATION_TYPE__DYNAMIC:
                            break;

                        case WorkBox.RELATION_TYPE__MANUAL_LINK:
                        {
                            relatedWorkBox.LinkToWorkBox(newWorkBox, WorkBox.RELATION_TYPE__MANUAL_LINK);
                            break;
                        }

                        case WorkBox.RELATION_TYPE__CHILD:
                        {
                            relatedWorkBox.LinkToWorkBox(newWorkBox, WorkBox.RELATION_TYPE__CHILD);
                            newWorkBox.LinkToWorkBox(relatedWorkBox, WorkBox.RELATION_TYPE__PARENT);
                            break;
                        }

                        default:
                        {
                            WBUtils.shouldThrowError("Did not recognise the relation type: " + RelationType.Value);
                            break;
                        }
                        }

                        relatedWorkBox.Dispose();
                    }
                    collection.Dispose();

                    string html = "<h1>Successfully created</h1><p>Your new work box has been successfully created.</p>";

                    html += String.Format("<p>Go to your new work box: <a href=\"#\" onclick=\"javascript: dialogReturnOKAndRedirect('{0}');\">{1}</a></p>",
                                          newWorkBox.Url,
                                          newWorkBox.Title);


                    string pageTitle = Uri.EscapeDataString("Created new work box");
                    string pageText  = Uri.EscapeDataString(html);

                    string okPageUrl = "WorkBoxFramework/GenericOKPage.aspx";

                    string refreshQueryString = "?recordsTypeGUID=" + newWorkBox.RecordsType.Id.ToString();

                    newWorkBox.Dispose();

                    string queryString = "pageTitle=" + pageTitle + "&pageText=" + pageText + "&refreshQueryString=" + refreshQueryString;

                    longOperation.End(okPageUrl, SPRedirectFlags.RelativeToLayoutsPage, Context, queryString);
                }
            }
        }
Example #8
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                StringBuilder html = new StringBuilder();

                WBFarm farm = WBFarm.Local;

                teams = WBTaxonomy.GetTeams(SPContext.Current.Site);
                team  = WBTeam.GetFromTeamSite(teams, SPContext.Current);

                if (team == null)
                {
                    ErrorText.Text = "You do not appear to be viewing this form while on a team site.";
                    return;
                }

                if (!WBFarm.Local.IsCurrentUserSystemAdmin())
                {
                    ErrorText.Text = "Only team owners or system admin can invite individuals to a team.";
                    return;
                }

                List <List <String> > tableColumnThenRow = new List <List <String> >();


                // First we're going to add the list of group members on the team sites site collection:
                // Note that we're actually assuming here that the web part is being used on the teams sites site collection!
                SPGroup fromGroup = team.MembersGroup(SPContext.Current.Site);

                List <String> column = new List <String>();
                foreach (SPUser user in fromGroup.Users)
                {
                    column.Add(user.Name);
                }

                column.Sort();

                column.Insert(0, farm.TeamSitesSiteCollectionUrl);
                tableColumnThenRow.Add(column);



                String groupName = team.MembersGroupName;

                html.Append("<p>Checking synchronisation of team   : <b>").Append(team.Name).Append("</b></p>");
                html.Append("<p>The underlying SharePoint group is : <b>").Append(groupName).Append("</b></p>");

                SPSecurity.RunWithElevatedPrivileges(delegate()
                {
                    using (SPSite site = new SPSite(farm.TimerJobsManagementSiteUrl))
                        using (SPWeb web = site.OpenWeb())
                        {
                            SPList dailyJobs        = web.Lists[WBTimerTasksJob.DAILY_TIMER_TASKS__LIST_NAME];
                            SPView inOrderToExecute = dailyJobs.Views[WBTimerTasksJob.DAILY_TIMER_TASKS__ORDERED_VIEW_NAME];

                            foreach (SPListItem task in dailyJobs.GetItems(inOrderToExecute))
                            {
                                string command   = task.WBxGetColumnAsString(WBTimerTask.COLUMN_NAME__COMMAND);
                                string targetUrl = task.WBxGetColumnAsString(WBTimerTask.COLUMN_NAME__TARGET_URL);
                                string argument1 = task.WBxGetColumnAsString(WBTimerTask.COLUMN_NAME__ARGUMENT_1);

                                if (command == WBTimerTask.COMMAND__SYNCHRONISE_ALL_TEAMS)
                                {
                                    // Create a new column object:
                                    column = new List <String>();

                                    try
                                    {
                                        using (SPSite toSite = new SPSite(targetUrl))
                                        {
                                            toSite.AllowUnsafeUpdates         = true;
                                            toSite.RootWeb.AllowUnsafeUpdates = true;

                                            SPGroup toGroup = WBUtils.SyncSPGroup(SPContext.Current.Site, toSite, groupName);

                                            foreach (SPUser user in toGroup.Users)
                                            {
                                                column.Add(user.Name);
                                            }

                                            column.Sort();
                                        }
                                    }
                                    catch (Exception exception)
                                    {
                                        WBLogging.Teams.Unexpected("Something went wrong when trying to add a set of users to " + groupName + " on site collection " + targetUrl, exception);

                                        column.Add("Exception: " + exception.Message);
                                    }

                                    // First row in all columns is the URL of the site collection:
                                    column.Insert(0, targetUrl);

                                    tableColumnThenRow.Add(column);
                                }
                            }
                        }
                });

                html.Append("\n<table width='100%' cellpadding='2px' cellspacing='5px'>\n");

                int  columns     = tableColumnThenRow.Count;
                bool foundValues = true;

                html.Append("<tr>\n");
                for (int columnIndex = 0; columnIndex < columns; columnIndex++)
                {
                    html.Append("<th>").Append(tableColumnThenRow[columnIndex][0]).Append("</th>");
                }
                html.Append("</tr>\n");

                int rowIndex = 1;
                while (foundValues)
                {
                    foundValues = false;

                    html.Append("<tr>\n");
                    for (int columnIndex = 0; columnIndex < columns; columnIndex++)
                    {
                        if (tableColumnThenRow[columnIndex].Count > rowIndex)
                        {
                            html.Append("<td>").Append(tableColumnThenRow[columnIndex][rowIndex]).Append("</td>");
                            foundValues = true;
                        }
                        else
                        {
                            html.Append("<td></td>");
                        }
                    }
                    html.Append("</tr>\n");

                    rowIndex++;
                }

                html.Append("</table>\n");

                TeamSyncInformation.Text = html.ToString();
            }
        }
Example #9
0
        protected void Page_Load(object sender, EventArgs e)
        {
            manager = new WBRecordsManager(SPContext.Current.Web.CurrentUser.LoginName);

            if (WorkBox.IsWebAWorkBox(SPContext.Current.Web))
            {
                workBox = new WorkBox(SPContext.Current);
                team    = workBox.OwningTeam;
                functionalAreasTaxonomy = workBox.FunctionalAreasTaxonomy;
            }
            else
            {
                team = WBTeam.GetFromTeamSite(SPContext.Current);
                if (team != null)
                {
                    teamsTaxonomy           = team.Taxonomy;
                    functionalAreasTaxonomy = WBTaxonomy.GetFunctionalAreas(teamsTaxonomy);
                }
            }

            if (team == null)
            {
                WBLogging.Debug("Couldn't find a suitable team !!");
                return;
            }

            masterLibraryHasVersions = manager.Libraries.ProtectedMasterLibrary.List.EnableVersioning;

            RecordsLibraryFolders.TreeNodePopulate += new TreeNodeEventHandler(RecordsLibraryFolders_TreeNodePopulate);
            // RecordsLibraryFolders.SelectedNodeChanged += new EventHandler(RecordsLibraryFolders_SelectedNodeChanged);

            RecordsLibraryFolders.PopulateNodesFromClient = true;
            RecordsLibraryFolders.EnableClientScript      = true;

            treeState = new WBLocationTreeState(SPContext.Current.Web, WBRecordsManager.VIEW_MODE__BROWSE_FOLDERS, WBRecordsType.PROTECTIVE_ZONE__PUBLIC);

            if (!IsPostBack)
            {
                WBTermCollection <WBTerm> functionalAreas = team.FunctionalArea(functionalAreasTaxonomy);

                ViewState["SortColumn"]    = WBColumn.DatePublished.InternalName;
                ViewState["SortDirection"] = "Descending";

                /*
                 * TreeViewLocationCollection collection = new TreeViewLocationCollection(manager, , "", functionalAreas);
                 *
                 * RecordsLibraryFolders.DataSource = collection;
                 * RecordsLibraryFolders.DataBind();
                 */

                manager.PopulateWithFunctionalAreas(treeState, RecordsLibraryFolders.Nodes, WBRecordsManager.VIEW_MODE__BROWSE_FOLDERS, functionalAreas);
            }
            else
            {
                SetSelectedPath();
                if (!String.IsNullOrEmpty(selectedPath))
                {
                    ProcessSelection(selectedPath);
                }
            }
        }
Example #10
0
        protected void okButton_OnClick(object sender, EventArgs e)
        {
            SPSite site = SPContext.Current.Site;
            SPWeb  web  = SPContext.Current.Web;

            WBTaxonomy teams = WBTaxonomy.GetTeams(site);

            WBTeam team = null;

            if (TeamTerm.Enabled)
            {
                if (TeamTerm.Text != "" && ParentTeamTerm.Text != "")
                {
                    TeamTermStatus.Text = "You can only select either a direct term or the parent term, not both!";
                    return;
                }

                if (TeamTerm.Text == "" && ParentTeamTerm.Text == "")
                {
                    TeamTermStatus.Text = "You must select either a direct term or the parent term.";
                    return;
                }

                if (TeamTerm.Text != "")
                {
                    team = new WBTeam(teams, TeamTerm.Text);
                }
                else
                {
                    if (ParentTeamTerm.Text != "")
                    {
                        WBTerm parent = new WBTerm(teams, ParentTeamTerm.Text);

                        Term newTerm = parent.Term.CreateTerm(web.Title, WorkBox.LOCALE_ID_ENGLISH);
                        team = new WBTeam(teams, newTerm);
                    }
                }

                team.OwnersGroupName  = WBUtils.EntitiesToPropertyString(TeamOwnersSharePointUserGroup.ResolvedEntities, 1);
                team.MembersGroupName = WBUtils.EntitiesToPropertyString(TeamMembersSharePointUserGroup.ResolvedEntities, 1);
                team.TeamSiteUrl      = web.Url;
            }
            else
            {
                team = WBTeam.GetFromTeamSite(teams, web);
            }

            if (team == null)
            {
                TeamTermStatus.Text = "Had a problem finding or creating the term!";
                return;
            }

            team.Name    = TeamName.Text;
            web.Title    = TeamName.Text;
            team.Acronym = TeamAcronym.Text;

            team.SetInformationAssetOwner(InformationAssetOwner.WBxGetSingleResolvedUser(web));
            team.SetManager(site, TeamManager.WBxGetSingleResolvedUser(web));

            team.PublishersGroupName = WBUtils.EntitiesToPropertyString(TeamPublishersSharePointUserGroup.ResolvedEntities, 1);
            team.RecordsTypesListUrl = RecordsTypesListUrl.Text;

            if (!String.IsNullOrEmpty(TeamFunctionalAreas.Text))
            {
                team.FunctionalAreaUIControlValue = TeamFunctionalAreas.Text;
            }
            team.UseAllFunctionalAreas = UseAllFunctionalAreas.Checked;


            // This will actually update the web as well as the term.
            team.UpdateWithTeamSiteWeb(web);

            SPUtility.Redirect("settings.aspx", SPRedirectFlags.RelativeToLayoutsPage, Context);
        }
Example #11
0
        private Dictionary <String, String> FindRecordsTypesToList()
        {
            WBFarm farm = WBFarm.Local;

            Dictionary <String, String> typesToList = new Dictionary <String, String>();

            using (SPSite site = new SPSite(farm.ProtectedRecordsLibraryUrl))
            {
                WBTaxonomy subjectTags          = WBTaxonomy.GetSubjectTags(site);
                WBTaxonomy teamsTaxonomy        = WBTaxonomy.GetTeams(subjectTags);
                WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(teamsTaxonomy);

                Term   pageSeriesTagTerm   = subjectTags.GetSelectedTermByPath(FullSubjectTagPath);
                WBTerm localPageSubjectTag = null;
                if (pageSeriesTagTerm != null)
                {
                    localPageSubjectTag = new WBTerm(subjectTags, pageSeriesTagTerm);
                }

                if (localPageSubjectTag != null)
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        WBQuery query = new WBQuery();

                        WBQueryClause subjectTagClause = new WBQueryClause(WBColumn.SubjectTags, WBQueryClause.Comparators.Equals, localPageSubjectTag);
                        subjectTagClause.UseDescendants = false;
                        query.AddClause(subjectTagClause);

                        if (webPart.OnlyLiveRecords)
                        {
                            WBQueryClause isLiveClause = new WBQueryClause(WBColumn.LiveOrArchived, WBQueryClause.Comparators.Equals, WBColumn.LIVE_OR_ARCHIVED__LIVE);
                            query.AddClause(isLiveClause);
                        }

                        /*
                         * else
                         * {
                         * string statusFilter = SelectedLiveOrArchivedStatusFilter;
                         * if (statusFilter == null || statusFilter == "") statusFilter = WBColumn.LIVE_OR_ARCHIVED__LIVE;
                         * if (statusFilter != "All")
                         * {
                         *  query.AddEqualsFilter(WBColumn.LiveOrArchived, statusFilter);
                         * }
                         * }
                         */

                        WBTeam team = null;
                        if (!String.IsNullOrEmpty(webPart.FilterByOwningTeam))
                        {
                            team = teamsTaxonomy.GetSelectedTeam(webPart.FilterByOwningTeam);

                            if (team != null)
                            {
                                query.AddEqualsFilter(WBColumn.OwningTeam, team);
                            }
                        }

                        query.AddViewColumn(WBColumn.Name);
                        query.AddViewColumn(WBColumn.Title);
                        query.AddViewColumn(WBColumn.RecordsType);

                        if (sortColumn == null)
                        {
                            sortColumn = WBColumn.ReferenceDate;
                            ascending  = false;
                        }

                        if (sortColumn != null)
                        {
                            query.OrderBy(sortColumn, ascending);
                        }

                        SPList recordsLibrary = web.GetList(farm.ProtectedRecordsLibraryUrl); //"Documents"]; //farm.RecordsCenterRecordsLibraryName];

                        SPListItemCollection listOfFoundDocuments = recordsLibrary.WBxGetItems(site, query);

                        foreach (SPListItem item in listOfFoundDocuments)
                        {
                            WBRecordsType recordsType     = item.WBxGetSingleTermColumn <WBRecordsType>(recordsTypesTaxonomy, WBColumn.RecordsType);
                            String        justRecordsType = GetJustRecordsTypeName(recordsType.Name);

                            if (!typesToList.ContainsKey(justRecordsType))
                            {
                                typesToList.Add(justRecordsType, recordsType.FullPath);
                            }
                        }
                    }
                }
                else
                {
                    WBLogging.Debug("pageSubjectTag was null");
                }
            }

            return(typesToList);
        }
        private SPListItemCollection getResultsForWorkBoxCollection(string workBoxCollectionURL, WBTeam team, WBRecordsType recordsType)
        {
            WBUtils.logMessage("Getting results for WBCollection: " + workBoxCollectionURL);

            using (WBCollection collection = new WBCollection(workBoxCollectionURL))
            {
                return(collection.QueryFilteredBy(team, recordsType, true));
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            // Get the selected parameters:
            string recordsTypeGUID = Request.Params["recordsTypeGUID"];
            string selectedWorkBoxCollectionURL = Request.Params["workBoxCollectionURL"];
            string includeDocumentsFlag         = Request.Params["includeDocuments"];

            WBTaxonomy teams        = WBTaxonomy.GetTeams(SPContext.Current.Site);
            WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(teams);

            WBTeam team = WBTeam.GetFromTeamSite(teams, SPContext.Current);

            if (recordsTypeGUID == null ||
                recordsTypeGUID == "" ||
                selectedWorkBoxCollectionURL == null ||
                selectedWorkBoxCollectionURL == "" ||
                team == null
                )
            {
                InformationText.Text = "<span>Make a selection from the left to see work boxes of that type.</span>";
            }
            else
            {
                Guid   teamsTermGuid = team.Id;
                string teamsGUID     = team.Id.ToString();

                // Process the parameters:
                bool includeDocumentRecords = false;
                if (includeDocumentsFlag != null && includeDocumentsFlag != "")
                {
                    includeDocumentRecords = includeDocumentsFlag.Equals(true.ToString());
                }

                WBRecordsType recordsType = null;
                Guid          selectedRecordsTypeTermGUID = new Guid(recordsTypeGUID);
                recordsType = recordsTypes.GetRecordsType(selectedRecordsTypeTermGUID);

                string infoText = "<div class='wbf-view-selected-records-type'>You have selected to view: <span 'wbf-records-type-name'>" + recordsType.Name + "</span></div>\n";

                if (recordsType.Description != "")
                {
                    infoText += "<div class='wbf-records-type-description'>" + recordsType.Description + "</div>";
                }

                InformationText.Text = infoText;


                WBUtils.logMessage("Found the records type info: " + recordsType.Name);

                DataTable combinedData = createCombinedDataTable();

                if (includeDocumentRecords)
                {
                    WBUtils.logMessage("Records Library IS being included in search");

                    WBFarm farm = WBFarm.Local;

                    //     SPListItemCollection docResults = getResultsForList(farm.RecordsCenterUrl, farm.RecordsCenterRecordsLibraryName, team, recordsType);

                    //   addDocResultsToCombinedData(farm.RecordsCenterUrl, docResults, combinedData);
                }
                else
                {
                    WBUtils.logMessage("Records Library is not being included in search");
                }

                if (selectedWorkBoxCollectionURL != "")
                {
                    using (WBCollection collection = new WBCollection(selectedWorkBoxCollectionURL))
                    {
                        WBUtils.logMessage("A work box colleciton IS being included in search: " + selectedWorkBoxCollectionURL);
                        SPListItemCollection workBoxResults = collection.QueryFilteredBy(team, recordsType, true);

                        WBUtils.logMessage("Got back from query this num of results: " + workBoxResults.Count);

                        addWorkBoxResultsToCombinedData(collection, workBoxResults, combinedData);

                        if (recordsType.CanCurrentUserCreateWorkBoxForTeam(collection, team))
                        {
                            string createNewURL  = collection.GetUrlForNewDialog(recordsType, team);
                            string createNewText = recordsType.CreateNewWorkBoxText;

                            CreateNewWorkBoxLink.Text = "<a href=\"#\" onclick=\"javascript: WorkBoxFramework_commandAction('" + createNewURL + "', 730, 800);\">" + createNewText + "</a>";
                        }
                    }
                }
                else
                {
                    WBUtils.logMessage("No work box colleciton is being included in search");
                }

                ShowCombinedResults.DataSource = combinedData;
                ShowCombinedResults.DataBind();
            }
        }
        private SPListItemCollection getResultsForList(string webURL, string listName, WBTeam team, WBRecordsType recordsType)
        {
            WBUtils.logMessage("Getting results for" + listName + " within " + webURL);
            using (SPSite site = new SPSite(webURL))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    SPList list = web.Lists[listName];

                    SPQuery query = site.WBxMakeCAMLQueryFilterBy(team, recordsType, true);

                    return(list.GetItems(query));
                }
            }
        }
Example #15
0
        private void RefreshBoundData()
        {
            if (SelectedWorkBoxView == VIEW__SELECTED_RECORDS_TYPE)
            {
                FilterOpenStatus.Enabled   = true;
                FilterClosedStatus.Enabled = true;
                FilterAllStatus.Enabled    = true;
            }
            else
            {
                FilterOpenStatus.Enabled   = false;
                FilterClosedStatus.Enabled = false;
                FilterAllStatus.Enabled    = false;

                ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "ClearHighlightedRecordsTypes", "$('a.ms-navitem').css('font-weight', 'normal');", 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.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);

            checkSortState();
            if (sortColumn != null)
            {
                query.OrderBy(sortColumn, ascending);
            }

            SelectedWorkBoxes.Columns.Clear();
            SelectedWorkBoxes.Columns.Add(WBUtils.FixedIconTemplateField(WorkBox.ICON_16_IMAGE_URL, WBColumn.WorkBoxURL));
            SelectedWorkBoxes.Columns.Add(WBUtils.HyperLinkField(WBColumn.Title, WBColumn.WorkBoxURL, sortColumn, ascending, ""));
            //                    SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
            //                        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));
            //    ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedTeams, sortColumn, ascending));

            switch (SelectedWorkBoxView)
            {
            case VIEW__RECENTLY_CREATED:
            {
                query.AddViewColumn(WBColumn.WorkBoxDateCreated);
                //query.AddViewColumn(WBColumn.RecordsType);
                SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateCreated, HorizontalAlign.Center, sortColumn, ascending));
                //SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, HorizontalAlign.Center, sortColumn, ascending));

                break;
            }

            case VIEW__RECENTLY_MODIFIED:
            {
                query.AddViewColumn(WBColumn.WorkBoxDateLastModified);
                //query.AddViewColumn(WBColumn.RecordsType);
                SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastModified, HorizontalAlign.Center, sortColumn, ascending));
                //SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, HorizontalAlign.Center, sortColumn, ascending));

                break;
            }

            case VIEW__RECENTLY_VISITED:
            {
                query.AddViewColumn(WBColumn.WorkBoxDateLastVisited);
                //query.AddViewColumn(WBColumn.RecordsType);
                SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastVisited, HorizontalAlign.Center, sortColumn, ascending));
                //SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, HorizontalAlign.Center, sortColumn, ascending));

                break;
            }

            case VIEW__SELECTED_RECORDS_TYPE:
            {
                query.AddViewColumn(WBColumn.ReferenceDate);

                SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));

                break;
            }
            }

            SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxStatus, HorizontalAlign.Center, sortColumn, ascending));


            WBRecordsType recordsType = null;
            WBTeam        team        = WBTeam.GetFromTeamSite(teams, SPContext.Current.Web);

            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 (SelectedWorkBoxView == VIEW__SELECTED_RECORDS_TYPE)
            {
                if (SelectedRecordsTypeGUID != "")
                {
                    recordsType = recordsTypes.GetRecordsType(new Guid(SelectedRecordsTypeGUID));
                }
                else if (!IsPostBack && !String.IsNullOrEmpty(webPart.InitialRecordsType))
                {
                    string initialRecordsTypePath = webPart.InitialRecordsType.Replace(" / ", "/").Trim();
                    recordsType = recordsTypes.GetSelectedRecordsType(initialRecordsTypePath);
                }

                if (recordsType != null)
                {
                    String recordsTypePath = recordsType.FullPath;
                    //recordsTypePath = recordsTypePath.Substring(1, recordsTypePath.Length - 1);
                    recordsTypePath = recordsTypePath.Replace("/", " / ");

                    SelectionTitle.Text       = recordsTypePath;
                    SelectionDescription.Text = recordsType.Description;

                    WBQueryClause recordsTypeClause = new WBQueryClause(WBColumn.RecordsType, WBQueryClause.Comparators.Equals, recordsType);
                    recordsTypeClause.UseDescendants = false;
                    query.AddClause(recordsTypeClause);

                    string statusFilter = SelectedWorkBoxStatusFilter;
                    if (statusFilter != "All")
                    {
                        query.AddEqualsFilter(WBColumn.WorkBoxStatus, statusFilter);
                    }

                    try
                    {
                        using (WBCollection collection = new WBCollection(recordsType.WorkBoxCollectionUrl))
                        {
                            DataTable dataTable = collection.Query(query);

                            SelectedWorkBoxes.DataSource = dataTable;
                            SelectedWorkBoxes.DataBind();

                            if (recordsType.CanCurrentUserCreateWorkBoxForTeam(collection, team))
                            {
                                string createNewURL  = collection.GetUrlForNewDialog(recordsType, team);
                                string createNewText = recordsType.CreateNewWorkBoxText;

                                CreateNewWorkBoxLink.Text = "<a href=\"#\" onclick=\"javascript: WorkBoxFramework_commandAction('" + createNewURL + "', 730, 800);\">" + createNewText + "</a>";
                            }
                            else
                            {
                                CreateNewWorkBoxLink.Text = "";
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        SelectedWorkBoxes.DataSource = null;
                        SelectedWorkBoxes.DataBind();

                        SelectionDescription.Text = SelectionDescription.Text + "<p><em>(An exception occured when trying to query the work boxes for this records type!)</em></p>";
                        CreateNewWorkBoxLink.Text = "";

                        WBLogging.RecordsTypes.Unexpected("Exception occurred on a team site when trying to query the work boxes of records type: " + recordsTypePath, exception);
                    }
                }
                else
                {
                    WBUtils.logMessage("SelectedRecordsTypeGUID was empty");
                }
            }
            else
            {
                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);

                    DataTable dataTable = cacheList.WBxGetDataTable(SPContext.Current.Site, query);

                    SelectedWorkBoxes.DataSource = dataTable;
                    SelectedWorkBoxes.DataBind();

                    CreateNewWorkBoxLink.Text = "";

                    SelectionTitle.Text       = SelectedWorkBoxView + " Work Boxes";
                    SelectionDescription.Text = "Select a category from left hand tree navigation to list work boxes of that type.";
                }
            }


            // OK so now to check that the right filters are highlighted:
            ViewRecentlyCreated.CssClass  = "";
            ViewRecentlyModified.CssClass = "";
            ViewRecentlyVisited.CssClass  = "";

            if (SelectedWorkBoxView == VIEW__RECENTLY_CREATED)
            {
                ViewRecentlyCreated.CssClass = "wbf-filter-selected";
            }
            if (SelectedWorkBoxView == VIEW__RECENTLY_MODIFIED)
            {
                ViewRecentlyModified.CssClass = "wbf-filter-selected";
            }
            if (SelectedWorkBoxView == VIEW__RECENTLY_VISITED)
            {
                ViewRecentlyVisited.CssClass = "wbf-filter-selected";
            }

            FilterByOwns.CssClass     = "";
            FilterByInvolved.CssClass = "";
            FilterByVisiting.CssClass = "";

            if (SelectedInvolvementFilter == FILTER_INVOLVEMENT__OWNS)
            {
                FilterByOwns.CssClass = "wbf-filter-selected";
            }
            if (SelectedInvolvementFilter == FILTER_INVOLVEMENT__INVOLVED)
            {
                FilterByInvolved.CssClass = "wbf-filter-selected";
            }
            if (SelectedInvolvementFilter == FILTER_INVOLVEMENT__VISITING)
            {
                FilterByVisiting.CssClass = "wbf-filter-selected";
            }

            FilterOpenStatus.CssClass   = "";
            FilterClosedStatus.CssClass = "";
            FilterAllStatus.CssClass    = "";

            if (SelectedWorkBoxStatusFilter == "Open")
            {
                FilterOpenStatus.CssClass = "wbf-filter-selected";
            }
            if (SelectedWorkBoxStatusFilter == "Closed")
            {
                FilterClosedStatus.CssClass = "wbf-filter-selected";
            }
            if (SelectedWorkBoxStatusFilter == "All")
            {
                FilterAllStatus.CssClass = "wbf-filter-selected";
            }
        }
Example #16
0
        private void BuildListOfAllowedTerms()
        {
            WBFarm farm = WBFarm.Local;

            using (SPSite site = new SPSite(farm.ProtectedRecordsLibraryUrl))
            {
                WBTaxonomy subjectTagsTaxonomy = WBTaxonomy.GetSubjectTags(site);
                WBTaxonomy teamsTaxonomy       = WBTaxonomy.GetTeams(subjectTagsTaxonomy);

                Term   pageSeriesTagTerm   = subjectTagsTaxonomy.GetSelectedTermByPath(FullSubjectTagPath);
                WBTerm localPageSubjectTag = null;
                if (pageSeriesTagTerm != null)
                {
                    localPageSubjectTag = new WBTerm(subjectTagsTaxonomy, pageSeriesTagTerm);
                }

                if (localPageSubjectTag != null)
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        WBQuery query = new WBQuery();

                        //WBQueryClause subjectTagClause = new WBQueryClause(WBColumn.SubjectTags, WBQueryClause.Comparators.Equals, localPageSubjectTag);
                        //subjectTagClause.UseDescendants = true;
                        //query.AddClause(subjectTagClause);

                        if (webPart.OnlyLiveRecords)
                        {
                            WBQueryClause isLiveClause = new WBQueryClause(WBColumn.LiveOrArchived, WBQueryClause.Comparators.Equals, WBColumn.LIVE_OR_ARCHIVED__LIVE);
                            query.AddClause(isLiveClause);
                        }

                        WBTeam team = null;
                        if (!String.IsNullOrEmpty(webPart.FilterByOwningTeam))
                        {
                            team = teamsTaxonomy.GetSelectedTeam(webPart.FilterByOwningTeam);

                            if (team != null)
                            {
                                query.AddEqualsFilter(WBColumn.OwningTeam, team);
                            }
                        }


                        /*
                         * string protectiveZoneFilter = "Public"; // Request.QueryString["ProtectiveZone"];
                         * if (protectiveZoneFilter != null && protectiveZoneFilter != "")
                         * {
                         *  query.AddEqualsFilter(WBColumn.ProtectiveZone, protectiveZoneFilter);
                         * }
                         * */

                        query.AddViewColumn(WBColumn.Name);
                        query.AddViewColumn(WBColumn.SubjectTags);

                        SPList recordsLibrary = web.GetList(farm.ProtectedRecordsLibraryUrl); //"Documents"]; //farm.RecordsCenterRecordsLibraryName];

                        SPListItemCollection documents = recordsLibrary.WBxGetItems(site, query);

                        WBLogging.Debug("Got documents back");

                        WBLogging.Debug("Documents contains " + documents.Count + " items");

                        foreach (SPListItem document in documents)
                        {
                            WBTermCollection <WBTerm> subjectTags = document.WBxGetMultiTermColumn <WBTerm>(subjectTagsTaxonomy, WBColumn.SubjectTags.DisplayName);
                            foreach (WBTerm subjectTag in subjectTags)
                            {
                                string fullPath = subjectTag.FullPath;
                                if (allUsedTerms.Contains(fullPath))
                                {
                                    WBLogging.Debug("Already has term: " + fullPath + "  so not adding");
                                }
                                else
                                {
                                    WBLogging.Debug("Adding to list of allowed terms: " + fullPath);
                                    this.allUsedTerms.Add(fullPath);
                                    while (fullPath.Contains("/"))
                                    {
                                        int lastIndex = fullPath.LastIndexOf('/');
                                        fullPath = fullPath.Substring(0, lastIndex);
                                        if (allUsedTerms.Contains(fullPath))
                                        {
                                            WBLogging.Debug("Already has term: " + fullPath + "  so not adding");
                                            fullPath = "";
                                        }
                                        else
                                        {
                                            allUsedTerms.Add(fullPath);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    WBUtils.logMessage("pageSubjectTag was null");
                }
            }
        }
Example #17
0
        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");
            }
        }
Example #18
0
        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();
            }
        }
Example #19
0
 private String renderTeamAsFieldSet(UserProfileManager profileManager, SPSite site, WBTeam team)
 {
     return(renderTeamAsFieldSet(profileManager, site, team, ""));
 }
Example #20
0
        private void RefreshBoundDocumentsList()
        {
            WBFarm farm = WBFarm.Local;

            // SC
            if (String.IsNullOrEmpty(farm.ProtectedRecordsLibraryUrl))
            {
                return;
            }

            bool foundDocuments = false;

            using (SPSite site = new SPSite(farm.ProtectedRecordsLibraryUrl))
            {
                WBTaxonomy subjectTags          = WBTaxonomy.GetSubjectTags(site);
                WBTaxonomy teamsTaxonomy        = WBTaxonomy.GetTeams(subjectTags);
                WBTaxonomy recordsTypesTaxonomy = WBTaxonomy.GetRecordsTypes(teamsTaxonomy);

                Term   pageSeriesTagTerm   = subjectTags.GetSelectedTermByPath(FullSubjectTagPath);
                WBTerm localPageSubjectTag = null;
                if (pageSeriesTagTerm != null)
                {
                    localPageSubjectTag = new WBTerm(subjectTags, pageSeriesTagTerm);
                }

                if (localPageSubjectTag != null)
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        WBQuery query = new WBQuery();

                        WBQueryClause subjectTagClause = new WBQueryClause(WBColumn.SubjectTags, WBQueryClause.Comparators.Equals, localPageSubjectTag);
                        subjectTagClause.UseDescendants = false;
                        query.AddClause(subjectTagClause);

                        if (webPart.OnlyLiveRecords)
                        {
                            WBQueryClause isLiveClause = new WBQueryClause(WBColumn.LiveOrArchived, WBQueryClause.Comparators.Equals, WBColumn.LIVE_OR_ARCHIVED__LIVE);
                            query.AddClause(isLiveClause);
                        }
                        else
                        {
                            string statusFilter = SelectedLiveOrArchivedStatusFilter;
                            if (statusFilter == null || statusFilter == "")
                            {
                                statusFilter = 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";
                            }
                        }

                        WBTeam team = null;
                        if (!String.IsNullOrEmpty(webPart.FilterByOwningTeam))
                        {
                            team = teamsTaxonomy.GetSelectedTeam(webPart.FilterByOwningTeam);

                            if (team != null)
                            {
                                query.AddEqualsFilter(WBColumn.OwningTeam, team);
                            }
                        }


                        if (webPart.ShowRecordTypes && !String.IsNullOrEmpty(recordsTypeFullPath) && recordsTypeFullPath != NO_RECORDS_TYPE_SELECTED)
                        {
                            WBRecordsType recordsTypeToFilterBy = recordsTypesTaxonomy.GetSelectedRecordsType(recordsTypeFullPath);

                            if (recordsTypeToFilterBy != null)
                            {
                                query.AddEqualsFilter(WBColumn.RecordsType, recordsTypeToFilterBy);
                            }
                        }

                        /*
                         * string protectiveZoneFilter = "Public"; // Request.QueryString["ProtectiveZone"];
                         * if (protectiveZoneFilter != null && protectiveZoneFilter != "")
                         * {
                         *  query.AddEqualsFilter(WBColumn.ProtectiveZone, protectiveZoneFilter);
                         * }
                         * */

                        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.LiveOrArchived);
                        query.AddViewColumn(WBColumn.RecordID);

//                        query.AddViewColumn(WBColumn.OwningTeam);
                        query.AddViewColumn(WBColumn.ReferenceDate);
                        //                     query.AddViewColumn(WBColumn.ReferenceID);
                        //                      query.AddViewColumn(WBColumn.SeriesTag);
//                        query.AddViewColumn(WBColumn.ProtectiveZone);
                        //query.AddViewColumn(WBColumn.DeclaredRecord);
                        //                    query.AddViewColumn(WBColumn.SubjectTags);

                        if (sortColumn == null)
                        {
                            sortColumn = WBColumn.ReferenceDate;
                            ascending  = false;
                        }

                        if (sortColumn != null)
                        {
                            query.OrderBy(sortColumn, ascending);
                        }

                        SPList recordsLibrary = web.GetList(farm.ProtectedRecordsLibraryUrl); //"Documents"]; //farm.RecordsCenterRecordsLibraryName];

                        DataTable dataTable = recordsLibrary.WBxGetDataTable(site, query);

                        if (dataTable.Rows.Count > 0)
                        {
                            foundDocuments = true;
                        }

                        DocumentsForSubject.DataSource = dataTable;

                        DocumentsForSubject.Columns.Clear();
                        DocumentsForSubject.Columns.Add(WBUtils.DynamicIconTemplateField(WBColumn.FileTypeIcon, WBColumn.EncodedAbsoluteURL));
                        DocumentsForSubject.Columns.Add(WBUtils.HyperLinkField(WBColumn.TitleOrName, WBColumn.EncodedAbsoluteURL, sortColumn, ascending));
                        DocumentsForSubject.Columns.Add(WBUtils.BoundField(WBColumn.FileType, sortColumn, ascending));
                        DocumentsForSubject.Columns.Add(WBUtils.BoundField(WBColumn.DisplayFileSize, sortColumn, ascending));
                        if (!webPart.OnlyLiveRecords)
                        {
                            DocumentsForSubject.Columns.Add(WBUtils.BoundField(WBColumn.LiveOrArchived, sortColumn, ascending));
                        }
                        DocumentsForSubject.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, sortColumn, ascending));


                        SPGroup rmManagersGroup = SPContext.Current.Web.WBxGetGroupOrNull(WBFarm.Local.RecordsManagersGroupName);

                        if (rmManagersGroup != null)
                        {
                            if (rmManagersGroup.ContainsCurrentUser)
                            {
                                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>";

                                DocumentsForSubject.Columns.Add(WBUtils.FormatStringTemplateField(formatString, valueColumns));
                            }
                        }


                        DocumentsForSubject.DataBind();
                    }
                }
                else
                {
                    WBUtils.logMessage("pageSubjectTag was null");
                }
            }


            if (foundDocuments && !webPart.OnlyLiveRecords)
            {
                showFilters = true;
            }

            if (!foundDocuments && !foundChildSubjectTags && !(onRootOfAtoZ))
            {
                int archivedDocs = 0;

                if (!webPart.OnlyLiveRecords)
                {
                    if (SelectedLiveOrArchivedStatusFilter == WBColumn.LIVE_OR_ARCHIVED__LIVE)
                    {
                        archivedDocs = this.CountArchivedDocsOfThisSelection();
                    }

                    showFilters = true;
                }

                if (archivedDocs > 0)
                {
                    DynamicNoDocumentsMessage.Text = "(No live documents have been found. There are " + archivedDocs + " archived documents of this type.)";
                }
                else
                {
                    DynamicNoDocumentsMessage.Text = "(No documents have been found)";
                }
            }
            else
            {
                DynamicNoDocumentsMessage.Text = "";
            }

            // Show Related docs header if docs or message being displayed
            if (DocumentsForSubject.Rows.Count > 0 || !String.IsNullOrEmpty(DynamicNoDocumentsMessage.Text))
            {
                h3RelatedDocs.Style.Add(HtmlTextWriterStyle.Display, "block");
            }
        }
Example #21
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                SPSite site = SPContext.Current.Site;
                SPWeb  web  = SPContext.Current.Web;

                WBTaxonomy teams           = WBTaxonomy.GetTeams(site);
                WBTaxonomy functionalAreas = WBTaxonomy.GetFunctionalAreas(teams);

                teams.InitialiseTaxonomyControl(TeamTerm, "Select Team Term", false);
                teams.InitialiseTaxonomyControl(ParentTeamTerm, "Select the Parent Team Term", false);
                functionalAreas.InitialiseTaxonomyControl(TeamFunctionalAreas, "Select the functional area", true);

                TeamName.Text = web.Title;

                WBTeam team = WBTeam.GetFromTeamSite(teams, web);
                if (team != null)
                {
                    TeamTerm.Text    = team.UIControlValue;
                    TeamAcronym.Text = team.Acronym;

                    TeamFunctionalAreas.Text      = team.FunctionalAreaUIControlValue;
                    UseAllFunctionalAreas.Checked = team.UseAllFunctionalAreas;

                    if (TeamFunctionalAreas.Text == "")
                    {
                        InheritedFunctionalAreas.Text = team.FunctionalArea(functionalAreas).Names();
                    }
                    else
                    {
                        InheritedFunctionalAreas.Text = "";
                    }

                    InformationAssetOwner.WBxInitialise(team.InformationAssetOwner(web));
                    TeamManager.WBxInitialise(team.Manager(web));

                    TeamOwnersSharePointUserGroup.UpdateEntities(WBUtils.CreateEntitiesArrayList(team.OwnersGroupName));
                    TeamMembersSharePointUserGroup.UpdateEntities(WBUtils.CreateEntitiesArrayList(team.MembersGroupName));
                    TeamPublishersSharePointUserGroup.UpdateEntities(WBUtils.CreateEntitiesArrayList(team.PublishersGroupName));

                    TeamTerm.Enabled       = false;
                    ParentTeamTerm.Enabled = false;
                    TeamOwnersSharePointUserGroup.Enabled  = false;
                    TeamMembersSharePointUserGroup.Enabled = false;
                    RecordsTypesListUrl.Text = team.RecordsTypesListUrl;
                }
                else
                {
                    TeamTerm.Text = "";

                    SPWeb  parentWeb  = web.ParentWeb;
                    WBTeam parentTeam = WBTeam.GetFromTeamSite(teams, parentWeb);

                    if (parentTeam != null)
                    {
                        ParentTeamTerm.Text = parentTeam.UIControlValue;

                        InheritedFunctionalAreas.Text = parentTeam.FunctionalArea(functionalAreas).Names();

                        RecordsTypesListUrl.Text = parentTeam.RecordsTypesListUrl;
                    }

                    TeamOwnersSharePointUserGroup.UpdateEntities(WBUtils.CreateEntitiesArrayList(web.Title + " - Owners"));
                    TeamMembersSharePointUserGroup.UpdateEntities(WBUtils.CreateEntitiesArrayList(web.Title + " - Members"));
                }
            }
        }
Example #22
0
        private String renderTeamAsFieldSet(UserProfileManager profileManager, SPSite site, WBTeam team, String involvedOrVisiting)
        {
            SPGroup group = team.MembersGroup(site);

            string html = "<fieldset><legend><a href=\"#\" onclick=\"javascript: dialogReturnOKAndRedirect('" + team.TeamSiteUrl + "');\">" + team.Name + "</a>";

            if (!String.IsNullOrEmpty(involvedOrVisiting) && currentUserCanRemoveTeams)
            {
                html += " <a href=\"javascript: removeTeam('" + involvedOrVisiting + "','" + team.Id.ToString() + "');\">(remove team)</a>";
            }

            html += "</legend><ul>\n";

            if (group == null)
            {
                html += "<i>(no user group defined for this team)</i>";
            }
            else
            {
                foreach (SPUser user in group.Users)
                {
                    html += "<li>" + renderUser(profileManager, user, "") + "</li>\n";
                }
            }


            html += "</ul></fieldset>\n";

            return(html);
        }
Example #23
0
        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();
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            webPart = this.Parent as TeamDetails;

            if (!IsPostBack)
            {
                WBTeam team = WBTeam.GetFromTeamSite(SPContext.Current);

                if (team == null)
                {
                    // then the SPContext is NOT on a team site
                    ListOfTeamOwners.Text  = "<i>(This web part is only for use in team sites)</i>";
                    ListOfTeamMembers.Text = "<i>(This web part is only for use in team sites)</i>";
                }
                else
                {
                    if (team.IsCurrentUserTeamOwnerOrSystemAdmin())
                    {
                        userIsTeamOwnerOrSystemAdmin = true;
                    }

                    List <String> ownerEmails   = new List <String>();
                    List <String> membersEmails = new List <String>();

                    ListOfTeamOwners.Text  = generateTable(team, team.OwnersGroupName, "Owner", "Team Owners", ownerEmails);
                    ListOfTeamMembers.Text = generateTable(team, team.MembersGroupName, "Member", "Team Members", membersEmails);

                    String teamActionsHTML = "";
                    if (userIsTeamOwnerOrSystemAdmin || webPart.ShowMailToLinks)
                    {
                        teamActionsHTML += "<h3>Team Actions:</h3>\n<ul>";

                        if (webPart.ShowMailToLinks)
                        {
                            teamActionsHTML += "<li>" + WBUtils.GenerateLinkToEmailGroup("Email team owners", ownerEmails) + "</li>";
                            teamActionsHTML += "<li>" + WBUtils.GenerateLinkToEmailGroup("Email team members", membersEmails) + "</li>";
                        }

                        if (userIsTeamOwnerOrSystemAdmin)
                        {
                            teamActionsHTML += "<li><a href=\"javascript: WorkBoxFramework_relativeCommandAction('InviteToTeamWithEmail.aspx', 0, 0); \">Invite user to team</a></li>";

                            if (team.IsCurrentUserTeamManagerOrSystemAdmin())
                            {
                                teamActionsHTML += "<li><a href=\"javascript: WorkBoxFramework_relativeCommandAction('ChangeTeamManager.aspx', 0, 0); \">Change team manager</a></li>";
                            }

                            if (webPart.ShowAddManagerReportsLinks)
                            {
                                if (String.IsNullOrEmpty(team.ManagerLogin))
                                {
                                    teamActionsHTML += "<li><i>Add manager's direct reports</i></li>";
                                    teamActionsHTML += "<li><i>Add all manager's reports</i></li>";
                                }
                                else
                                {
                                    teamActionsHTML += "<li><a href=\"javascript: WorkBoxFramework_relativeCommandAction('AddManagersDirectReports.aspx', 0, 0); \">Add manager's direct reports</a></li>";
                                    teamActionsHTML += "<li><a href=\"javascript: WorkBoxFramework_relativeCommandAction('AddAllManagersReports.aspx', 0, 0); \">Add all manager's reports</a></li>";
                                }
                            }

                            if (WBFarm.Local.IsCurrentUserSystemAdmin())
                            {
                                teamActionsHTML += "<li><a href=\"javascript: WorkBoxFramework_relativeCommandAction('CheckTeamSync.aspx', 0, 0); \">Check team synchronisation</a></li>";
                            }
                        }
                        teamActionsHTML += "\n</ul>";
                    }
                    TeamActions.Text = teamActionsHTML;
                }
            }
        }
        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);
                        }
                    }
                }
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            DialogTitle.Text = "An Error Occurred";

            if (!WorkBox.CurrentUserIsOwner() && !WorkBox.CurrentUserIsBusinessAdmin() && !WorkBox.CurrentUserIsSystemAdmin())
            {
                AreYouSureText.Text  = "Only owners or admin can remove teams or individuals from having access to a work box.";
                RemoveButton.Enabled = false;
                return;
            }

            if (!IsPostBack)
            {
                TeamOrIndividual.Value   = Request.QueryString["TeamOrIndividual"];
                InvolvedOrVisiting.Value = Request.QueryString["InvolvedOrVisiting"];

                if (TeamOrIndividual.Value == "Team")
                {
                    GUIDOfTeamToRemove.Value = Request.QueryString["GUIDOfTeamToRemove"];
                }

                if (TeamOrIndividual.Value == "Individual")
                {
                    LoginNameOfUserToRemove.Value = Request.QueryString["LoginNameOfUserToRemove"];
                }

                CancelButton.Focus();
            }

            if (String.IsNullOrEmpty(TeamOrIndividual.Value))
            {
                AreYouSureText.Text = "Error in the parameters sent to this dialog.";
                return;
            }

            AreYouSureText.Text = "Odd error in the parameters sent to this dialog.";

            if (TeamOrIndividual.Value == "Team" && !String.IsNullOrEmpty(GUIDOfTeamToRemove.Value))
            {
                teams = WBTaxonomy.GetTeams(SPContext.Current.Site);

                team = teams.GetTeam(new Guid(GUIDOfTeamToRemove.Value));

                if (!IsPostBack)
                {
                    if (InvolvedOrVisiting.Value == "Involved")
                    {
                        DialogTitle.Text            = "Remove Involved Team";
                        AreYouSureText.Text         = "Are you sure you want to remove the following team from being involved with this work box?";
                        NameOfTeamOrIndividual.Text = "Removing involved team: <b>" + team.Name + "</b>";
                    }
                    else
                    {
                        DialogTitle.Text            = "Remove Visiting Team";
                        AreYouSureText.Text         = "Are you sure you want to remove the following team from being able to visit this work box?";
                        NameOfTeamOrIndividual.Text = "Removing visiting team: <b>" + team.Name + "</b>";
                    }
                }
            }

            if (TeamOrIndividual.Value == "Individual" && !String.IsNullOrEmpty(LoginNameOfUserToRemove.Value))
            {
                user = WorkBox.Web.WBxEnsureUserOrNull(LoginNameOfUserToRemove.Value);

                if (!IsPostBack)
                {
                    if (InvolvedOrVisiting.Value == "Involved")
                    {
                        DialogTitle.Text            = "Remove Involved Individual";
                        AreYouSureText.Text         = "Are you sure you want to remove the following individual from being involved with this work box?";
                        NameOfTeamOrIndividual.Text = "Removing involved individual: <b>" + user.Name + "</b>";
                    }
                    else
                    {
                        DialogTitle.Text            = "Remove Visiting Individual";
                        AreYouSureText.Text         = "Are you sure you want to remove the following individual from being able to visit this work box?";
                        NameOfTeamOrIndividual.Text = "Removing visiting individual: <b>" + user.Name + "</b>";
                    }
                }
            }

            if (!IsPostBack)
            {
                DisposeWorkBox();
            }
        }
Example #27
0
        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);
                        }
                    }
                }
            }
        }
Example #28
0
        private void resetPanelToSelectedTermValues()
        {
            WBTeam team = teams.GetSelectedTeam(AllTeamsTreeView.SelectedNode.ValuePath);

            updatePanelWithTeamDetails(team);
        }
Example #29
0
        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 (!String.IsNullOrEmpty(SelectedRecordsTypeGUID))
            {
                WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
                WBTaxonomy teams = WBTaxonomy.GetTeams(recordsTypes);

                WBRecordsType recordsType = recordsTypes.GetRecordsType(new Guid(SelectedRecordsTypeGUID));

                String recordsTypePath = recordsType.FullPath;
                //recordsTypePath = recordsTypePath.Substring(1, recordsTypePath.Length - 1);
                recordsTypePath = recordsTypePath.Replace("/", " / ");

                SelectionTitle.Text = recordsTypePath;
                SelectionDescription.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 = false;
                    query.AddClause(recordsTypeClause);

                    if (team != null)
                    {
                        query.AddEqualsFilter(WBColumn.InvolvedTeams, team);
                    }

                    string statusFilter = SelectedWorkBoxStatusFilter;
                    if (statusFilter == null || statusFilter == "") statusFilter = "Open";
                    if (statusFilter != "All")
                    {
                        query.AddEqualsFilter(WBColumn.WorkBoxStatus, statusFilter);
                    }

                    FilterOpenStatus.CssClass = "wbf-unselected-filter";
                    FilterClosedStatus.CssClass = "wbf-unselected-filter";
                    FilterAllStatus.CssClass = "wbf-unselected-filter";

                    if (statusFilter == "Open") FilterOpenStatus.CssClass = "wbf-selected-filter";
                    if (statusFilter == "Closed") FilterClosedStatus.CssClass = "wbf-selected-filter";
                    if (statusFilter == "All") FilterAllStatus.CssClass = "wbf-selected-filter";


                    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);

                    SelectedWorkBoxes.DataSource = dataTable;

                    SelectedWorkBoxes.Columns.Clear();
                    SelectedWorkBoxes.Columns.Add(WBUtils.FixedIconTemplateField(WorkBox.ICON_16_IMAGE_URL, WBColumn.WorkBoxURL));
                    SelectedWorkBoxes.Columns.Add(WBUtils.HyperLinkField(WBColumn.Title, WBColumn.WorkBoxURL, sortColumn, ascending));
//                    SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
                    //                        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));
                    //    ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedTeams, sortColumn, ascending));
                    SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxStatus, sortColumn, ascending));


                    SelectedWorkBoxes.DataBind();



                    if (recordsType.CanCurrentUserCreateWorkBoxForTeam(collection, team))
                    {
                        string createNewURL = collection.GetUrlForNewDialog(recordsType, team);
                        string createNewText = recordsType.CreateNewWorkBoxText;

                        CreateNewWorkBoxLink.Text = "<a href=\"#\" onclick=\"javascript: WorkBoxFramework_commandAction('" + createNewURL + "', 730, 800);\">" + createNewText + "</a>";
                    }
                    else
                    {
                        CreateNewWorkBoxLink.Text = "";
                    }



                    // }
                }
            }
            else
            {
                WBUtils.logMessage("SelectedRecordsTypeGUID was empty");
            }

        }