Пример #1
0
        public void SharepointUtils_BuildCamlQuery_ValidFilters_HasQueryWithAnd()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var camlQuery = sharepointUtils.BuildCamlQuery(new ExecutionEnvironment(), new List <SharepointSearchTo> {
                new SharepointSearchTo("Title", "Equal", "Bob", 1)
                {
                    InternalName = "Title"
                }, new SharepointSearchTo("ID", "Equal", "1", 1)
                {
                    InternalName = "ID"
                }
            }, new List <ISharepointFieldTo> {
                new SharepointFieldTo {
                    InternalName = "Title", Type = SharepointFieldType.Text
                }, new SharepointFieldTo {
                    InternalName = "ID", Type = SharepointFieldType.Number
                }
            }, 0);

            //------------Assert Results-------------------------
            Assert.AreEqual("<View><Query><Where><And><FieldRef Name=\"Title\"></FieldRef><Value Type=\"Text\">Bob</Value>" + Environment.NewLine + "<FieldRef Name=\"ID\"></FieldRef><Value Type=\"Integer\">1</Value>" + Environment.NewLine + "</And></Where></Query></View>", camlQuery.ViewXml);
        }
        /// <summary>
        /// Checkout document
        /// </summary>
        /// <param name="localCheckout">Whether document should be checked out locally or on the server side</param>
        /// <returns>
        /// Whether check out process has completed successfully
        /// </returns>
        public bool CheckOut(bool localCheckout)
        {
            string documentUrl = StringUtil.EnsurePostfix('/', this.context.Url) + StringUtil.RemovePrefix('/', this.document.FileRef);

            SharepointUtils.LogDebugInfo(this.context, "Checking out file: [" + documentUrl + "]");
            return(this.ListsWebService.CheckOutFile(documentUrl, localCheckout ? "true" : "false", string.Empty));
        }
        protected void advancedSearchBtn_Click(object sender, EventArgs e)
        {
            advancedSearchBtn.Text          = "»&nbsp;" + Translate.Text(UIMessages.AdvancedSearch);
            advancedSearchSitesPane.Visible = !advancedSearchSitesPane.Visible;
            advancedSearchListsPane.Visible = !advancedSearchListsPane.Visible;

            if (advancedSearchSitesPane.Visible)
            {
                advancedSearchBtn.Text = "»&nbsp;" + Translate.Text(UIMessages.AdvancedSearch);
                Server spServer = ObjectModel.Entities.Server.Connect(SpContext);
                try
                {
                    List <System.Web.UI.WebControls.ListItem> webs = new List <System.Web.UI.WebControls.ListItem> {
                        new System.Web.UI.WebControls.ListItem(Translate.Text(UIMessages.AllSites), this.Web)
                    };
                    webs.AddRange(spServer.Webs.Select(web => new ListItem(web.Title, web.Path)));
                    if ((webs.Count > 0))
                    {
                        sitesList.DataSource = webs;
                    }
                    sitesList.DataTextField  = "Text";
                    sitesList.DataValueField = "Value";
                    sitesList.DataBind();

                    listsList.DataSource = new[] { new System.Web.UI.WebControls.ListItem(Translate.Text(UIMessages.AllLists)) };
                    listsList.DataBind();
                    AttemptNumber = 0;
                }
                catch (WebException ex)
                {
                    sitesList.DataSource = new[] { new System.Web.UI.WebControls.ListItem(Translate.Text(UIMessages.AllSites), this.Web) };
                    sitesList.DataBind();

                    listsList.DataSource = new[] { new System.Web.UI.WebControls.ListItem(Translate.Text(UIMessages.AllLists)) };
                    listsList.DataBind();

                    errorLbl.Text = Translate.Text(UIMessages.CouldntGetResponseFromSharepointServer);
                    HttpWebResponse webResponse = ex.Response as HttpWebResponse;
                    if ((webResponse != null) && (webResponse.StatusCode == HttpStatusCode.Unauthorized) &&
                        (webResponse.Headers.AllKeys.Contains("WWW-Authenticate")))
                    {
                        errorLbl.Text = Translate.Text(UIMessages.YouDoNotHaveEnoughRights);
                        if (AttemptNumber < 3)
                        {
                            SharepointExtension.WriteAuthenticationResponseBasic(Request, Response);
                            AttemptNumber++;
                        }
                    }
                    this.ShowErrorLabel();
                    return;
                }
                catch (SoapException ex)
                {
                    SharepointUtils.LogDebugInfo(SpContext, "Can't retrieve info for advanced search");
                    return;
                }
            }
        }
Пример #4
0
        public void SharepointUtils_CastWarewolfValueToCorrectType_Date_ShouldGiveDateValueValue()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var value = SharepointUtils.CastWarewolfValueToCorrectType(DateTime.Now, SharepointFieldType.DateTime);

            //------------Assert Results-------------------------
            Assert.IsInstanceOfType(value, typeof(DateTime));
        }
Пример #5
0
        public void SharepointUtils_CastWarewolfValueToCorrectType_Currency_ShouldGiveDecimalValue()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var value = SharepointUtils.CastWarewolfValueToCorrectType("2.01", SharepointFieldType.Currency);

            //------------Assert Results-------------------------
            Assert.IsInstanceOfType(value, typeof(Decimal));
        }
Пример #6
0
        public void SharepointUtils_CastWarewolfValueToCorrectType_Note_ShouldGiveStringValue()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var value = SharepointUtils.CastWarewolfValueToCorrectType("Bob", SharepointFieldType.Note);

            //------------Assert Results-------------------------
            Assert.IsInstanceOfType(value, typeof(String));
        }
Пример #7
0
        public void SharepointUtils_CastWarewolfValueToCorrectType_Boolean_ShouldGiveBoolValue()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var value = SharepointUtils.CastWarewolfValueToCorrectType("true", SharepointFieldType.Boolean);

            //------------Assert Results-------------------------
            Assert.IsInstanceOfType(value, typeof(Boolean));
        }
Пример #8
0
        public void SharepointUtils_BuildCamlQuery_NoFilters_ShouldBeCreateAllItemsQuery()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var camlQuery = sharepointUtils.BuildCamlQuery(new ExecutionEnvironment(), new List <SharepointSearchTo>(), new List <ISharepointFieldTo>(), 0);

            //------------Assert Results-------------------------
            Assert.AreEqual(CamlQuery.CreateAllItemsQuery().ViewXml, camlQuery.ViewXml);
        }
        /// <summary>
        /// Check in document
        /// </summary>
        /// <param name="comment">The comment for SharePoint</param>
        /// <param name="checkInType">The check in type. Possible values
        /// A string representation of the values 0, 1 or 2, where 0 = MinorCheckIn, 1 = MajorCheckIn, and 2 = OverwriteCheckIn.</param>
        /// <returns>
        /// Whether check in process has completed successfully
        /// </returns>
        public bool CheckIn([NotNull] string comment, [NotNull] string checkInType)
        {
            Assert.ArgumentNotNull(comment, "comment");
            Assert.ArgumentNotNull(checkInType, "checkInType");

            string documentUrl = StringUtil.EnsurePostfix('/', this.context.Url) + StringUtil.RemovePrefix('/', this.document.FileRef);

            SharepointUtils.LogDebugInfo(this.context, "Checking in file: [" + documentUrl + "]");

            return(this.ListsWebService.CheckInFile(documentUrl, comment, checkInType));
        }
Пример #10
0
        public void SharepointUtils_CastWarewolfValueToCorrectType_Integer_ShouldGiveIntValue()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var value = SharepointUtils.CastWarewolfValueToCorrectType("2", SharepointFieldType.Integer);

            //------------Assert Results-------------------------
            Assert.IsInstanceOfType(value, typeof(Int32));
        }
Пример #11
0
        public void SharepointUtils_GetValidReadListItems_NullList_EmptyList()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var validList = SharepointUtils.GetValidReadListItems(null);

            //------------Assert Results-------------------------
            Assert.IsNotNull(validList);
            Assert.AreEqual(0, validList.Count());
        }
Пример #12
0
        public void SharepointUtils_GetValidReadListItems_WhereVariableNameEmpty_ListWithoutItem()
        {
            //------------Setup for test--------------------------
            var sharepointUtils = new SharepointUtils();

            //------------Execute Test---------------------------
            var validList = SharepointUtils.GetValidReadListItems(new List <SharepointReadListTo> {
                new SharepointReadListTo("Bob", "Title", "Title", ""), new SharepointReadListTo("", "Title", "Title", "")
            });

            //------------Assert Results-------------------------
            Assert.IsNotNull(validList);
            var tos = validList as IList <SharepointReadListTo> ?? validList.ToList();

            Assert.AreEqual(1, tos.Count);
            Assert.AreEqual("Bob", tos[0].VariableName);
        }
        protected void sitesList_IndexChanged(object sender, EventArgs e)
        {
            List <System.Web.UI.WebControls.ListItem> lists = new List <System.Web.UI.WebControls.ListItem> {
                new System.Web.UI.WebControls.ListItem(Translate.Text(UIMessages.AllLists))
            };

            listsList.DataSource = null;
            listsList.Items.Clear();
            string siteName = sitesList.SelectedValue;

            if (!string.IsNullOrEmpty(siteName) && (sitesList.SelectedIndex > 0))
            {
                Server spServer = ObjectModel.Entities.Server.Connect(SpContext);
                try
                {
                    Web selectedWeb = spServer.Webs.First(web => web.Path == siteName);
                    if (selectedWeb != null)
                    {
                        lists.AddRange(selectedWeb.Lists.Select(list => new ListItem(list.Name, list is ObjectModel.Entities.Lists.List ? "Lists/" + list.Name : list.Name)));
                    }
                }
                catch (WebException ex)
                {
                    HttpWebResponse webResponse = ex.Response as HttpWebResponse;
                    if ((webResponse != null) && (webResponse.StatusCode == HttpStatusCode.Unauthorized) &&
                        (webResponse.Headers.AllKeys.Contains("WWW-Authenticate")))
                    {
                        SharepointExtension.WriteAuthenticationResponseBasic(Request, Response);
                    }
                    return;
                }
                catch (SoapException ex)
                {
                    SharepointUtils.LogDebugInfo(SpContext, "Couldn't retrieve lists for {0} site.\n{1}", siteName, ex.StackTrace);
                    return;
                }
            }
            listsList.DataTextField  = "Text";
            listsList.DataValueField = "Value";
            listsList.DataSource     = lists;
            listsList.DataBind();
        }
Пример #14
0
        public void SharepointUtils_BuildCamlQuery_ValidFilter_In_TextResultCommaSeperated()
        {
            //------------Setup for test--------------------------
            var sharepointUtils      = new SharepointUtils();
            var executionEnvironment = new ExecutionEnvironment();
            //------------Execute Test---------------------------
            var camlQuery = sharepointUtils.BuildCamlQuery(executionEnvironment, new List <SharepointSearchTo> {
                new SharepointSearchTo("Title", "In", "bob,dora", 1)
                {
                    InternalName = "Title"
                }
            }, new List <ISharepointFieldTo> {
                new SharepointFieldTo {
                    InternalName = "Title", Type = SharepointFieldType.Text
                }
            }, 0);

            //------------Assert Results-------------------------
            Assert.AreEqual("<View><Query><Where><In><FieldRef Name=\"Title\"></FieldRef><Values><Value Type=\"Text\">bob</Value><Value Type=\"Text\">dora</Value></Values></In>" + Environment.NewLine + "</Where></Query></View>", camlQuery.ViewXml);
        }
Пример #15
0
        protected void Initialize(string serverUrl, ICredentials serverCredentials)
        {
            if (string.IsNullOrEmpty(serverUrl))
            {
                serverUrl = SharepointUtils.CurrentSharepointServer;
            }

            this.Url = serverUrl;
            if (serverCredentials == null)
            {
                serverCredentials = this.GetPredefinedCredentials();
                if (serverCredentials == null)
                {
                    serverCredentials = CredentialCache.DefaultNetworkCredentials;
                    this.Credentials  = serverCredentials;
                    SharepointUtils.LogDebugInfo(this, "Using DefaultNetworkCredentials");
                }
            }

            this.Credentials = serverCredentials;
            this.InitConfiguration();
        }
Пример #16
0
        /// <summary>Creates context.</summary>
        /// <param name="sharepointServer">The SharePoint server.</param>
        /// <param name="web">The web.</param>
        /// <param name="predefinedContext">The predefined context.</param>
        /// <param name="credentials">The credentials.</param>
        /// <param name="connectionConfiguration">The connection configuration.</param>
        /// <returns>The <see cref="SpContext"/>.</returns>
        protected virtual SpContext CreateContext(string sharepointServer, string web, string predefinedContext, ICredentials credentials = null, string connectionConfiguration = null)
        {
            var context = new SpContext
            {
                Url                     = !string.IsNullOrEmpty(sharepointServer) ? sharepointServer : SharepointUtils.CurrentSharepointServer,
                Credentials             = credentials,
                ConnectionConfiguration = connectionConfiguration
            };

            if (!string.IsNullOrEmpty(context.ConnectionConfiguration) && context.Credentials != null)
            {
                return(context);
            }

            ServerEntry serverEntry = this.GetServerEntry(StringUtil.EnsurePostfix('/', sharepointServer) + StringUtil.RemovePrefix('/', web), predefinedContext);

            if (serverEntry != null)
            {
                if (string.IsNullOrEmpty(context.ConnectionConfiguration))
                {
                    context.ConnectionConfiguration = serverEntry.ConnectionConfiguration;
                }

                if (context.Credentials == null)
                {
                    context.Credentials = serverEntry.Credentials;
                }
            }

            if (context.Credentials == null)
            {
                context.Credentials = this.DefaultCredentials;
                SharepointUtils.LogDebugInfo(context, "Using DefaultNetworkCredentials");
            }

            return(context);
        }
Пример #17
0
        public void SharepointReadListActivity_GetState()
        {
            //------------Setup for test--------------------------
            const string activityName   = "SharepointReadList";
            var          resourceId     = Guid.NewGuid();
            var          filterCriteria = new List <SharepointSearchTo>()
            {
                new SharepointSearchTo("A", "A", "", 1)
            };

            var sharepointList             = "SharepointList";
            var requireAllCriteriaToMatch  = true;
            var readListItems              = new List <SharepointReadListTo>();
            var sharepointUtils            = new SharepointUtils();
            var sharepointReadListActivity = new SharepointReadListActivity
            {
                DisplayName = activityName,
                SharepointServerResourceId = resourceId,
                ReadListItems             = readListItems,
                FilterCriteria            = filterCriteria,
                SharepointList            = sharepointList,
                RequireAllCriteriaToMatch = requireAllCriteriaToMatch,
                SharepointUtils           = sharepointUtils
            };
            var dataObj         = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>());
            var resourceCatalog = new Mock <IResourceCatalog>();
            var privateObject   = new PrivateObject(sharepointReadListActivity);

            privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
            //------------Execute Test---------------------------
            privateObject.Invoke("ExecuteTool", dataObj, 0);
            var serializer      = new Dev2JsonSerializer();
            var expectedResults = new[]
            {
                new StateVariable
                {
                    Name  = "SharepointServerResourceId",
                    Type  = StateVariable.StateType.Input,
                    Value = resourceId.ToString()
                },
                new StateVariable
                {
                    Name  = "ReadListItems",
                    Type  = StateVariable.StateType.InputOutput,
                    Value = ActivityHelper.GetSerializedStateValueFromCollection(readListItems)
                },
                new StateVariable
                {
                    Name  = "FilterCriteria",
                    Type  = StateVariable.StateType.Input,
                    Value = ActivityHelper.GetSerializedStateValueFromCollection(filterCriteria)
                },
                new StateVariable
                {
                    Name  = "RequireAllCriteriaToMatch",
                    Type  = StateVariable.StateType.Input,
                    Value = requireAllCriteriaToMatch.ToString()
                },
                new StateVariable
                {
                    Name  = "SharepointList",
                    Type  = StateVariable.StateType.Input,
                    Value = sharepointList
                }
            };
            //---------------Test Result -----------------------
            var stateItems = sharepointReadListActivity.GetState();

            Assert.AreEqual(5, stateItems.Count());
            var iter = stateItems.Select(
                (item, index) => new
            {
                value       = item,
                expectValue = expectedResults[index]
            }
                );

            //------------Assert Results-------------------------
            foreach (var entry in iter)
            {
                Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
                Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
                Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
            }
        }