public WebPartDefinition ImportWebPart(string webPartXml)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (webPartXml == null)
                {
                    throw ClientUtility.CreateArgumentNullException("webPartXml");
                }
                if (webPartXml != null && webPartXml.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("webPartXml");
                }
            }
            WebPartDefinition webPartDefinition = new WebPartDefinition(context, new ObjectPathMethod(context, base.Path, "ImportWebPart", new object[]
            {
                webPartXml
            }));

            webPartDefinition.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(webPartDefinition.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, webPartDefinition);
            context.AddQuery(objectIdentityQuery);
            return(webPartDefinition);
        }
Пример #2
0
        public void MoveWebPartTo(string zoneID, int zoneIndex)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (zoneID == null)
                {
                    throw ClientUtility.CreateArgumentNullException("zoneID");
                }
                if (zoneID != null && zoneID.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("zoneID");
                }
                if (zoneID != null && zoneID.Length > 64)
                {
                    throw ClientUtility.CreateArgumentException("zoneID");
                }
                if (zoneIndex < 0)
                {
                    throw ClientUtility.CreateArgumentException("zoneIndex");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "MoveWebPartTo", new object[]
            {
                zoneID,
                zoneIndex
            });

            context.AddQuery(query);
        }
        private void InitFederationProviderInfoForUser(string username)
        {
            int num = username.IndexOf('@');

            if (num < 0 || num == username.Length - 1)
            {
                throw ClientUtility.CreateArgumentException("username");
            }
            string domainname = username.Substring(num + 1);

            IdcrlAuth.FederationProviderInfo federationProviderInfo = this.GetFederationProviderInfo(domainname);
            if (federationProviderInfo != null)
            {
                this.m_userRealmServiceUrl     = federationProviderInfo.UserRealmServiceUrl;
                this.m_securityTokenServiceUrl = federationProviderInfo.SecurityTokenServiceUrl;
                this.m_federationTokenIssuer   = federationProviderInfo.FederationTokenIssuer;
            }
            ClientULS.SendTraceTag(3454936u, ClientTraceCategory.Authentication, ClientTraceLevel.Verbose, "UserName={0}, UserRealmServiceUrl={1}, SecurityTokenServiceUrl={1}, FederationTokenIssuer={2}", new object[]
            {
                username,
                this.m_userRealmServiceUrl,
                this.m_securityTokenServiceUrl,
                this.m_federationTokenIssuer
            });
        }
Пример #4
0
        public Field AddFieldAsXml(string schemaXml, bool addToDefaultView, AddFieldOptions options)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (schemaXml == null)
                {
                    throw ClientUtility.CreateArgumentNullException("schemaXml");
                }
                if (schemaXml != null && schemaXml.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("schemaXml");
                }
            }
            Field field = new Field(context, new ObjectPathMethod(context, base.Path, "AddFieldAsXml", new object[]
            {
                schemaXml,
                addToDefaultView,
                options
            }));

            field.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(field.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, field);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(field);
            return(field);
        }
Пример #5
0
        public File AddTemplateFile(string urlOfFile, TemplateFileType templateFileType)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (urlOfFile == null)
                {
                    throw ClientUtility.CreateArgumentNullException("urlOfFile");
                }
                if (urlOfFile != null && urlOfFile.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("urlOfFile");
                }
                if (templateFileType != TemplateFileType.StandardPage && templateFileType != TemplateFileType.WikiPage && templateFileType != TemplateFileType.FormPage && templateFileType != TemplateFileType.ClientSidePage)
                {
                    throw ClientUtility.CreateArgumentException("templateFileType");
                }
            }
            File file = new File(context, new ObjectPathMethod(context, base.Path, "AddTemplateFile", new object[]
            {
                urlOfFile,
                templateFileType
            }));

            file.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(file.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, file);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(file);
            return(file);
        }
        public Web Add(WebCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Url == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Url");
                    }
                    if (parameters.Url != null && parameters.Url.Length > 128)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                    if (parameters.Url.StartsWith("/", StringComparison.OrdinalIgnoreCase) || parameters.Url.StartsWith(".", StringComparison.OrdinalIgnoreCase) || parameters.Url.EndsWith("/", StringComparison.OrdinalIgnoreCase) || parameters.Url.EndsWith(".", StringComparison.OrdinalIgnoreCase))
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                    if (parameters.Url.IndexOf("//", StringComparison.OrdinalIgnoreCase) >= 0 || parameters.Url.IndexOf("..", StringComparison.OrdinalIgnoreCase) >= 0)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                    if (parameters.Url.IndexOf("/wpresources", StringComparison.OrdinalIgnoreCase) >= 0)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                    if (parameters.Title != null && parameters.Title.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                }
            }
            Web web = new Web(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            web.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(web.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, web);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(web);
            web.InitFromCreationInformation(parameters);
            return(web);
        }
Пример #7
0
        public RoleDefinition Add(RoleDefinitionCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Name == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Name");
                    }
                    if (parameters.Name != null && parameters.Name.Length == 0)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Name");
                    }
                    if (parameters.Name != null && parameters.Name.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Name");
                    }
                    if (parameters.Name != null && !Regex.Match(parameters.Name, "^[^\\[\\]/\\\\:\\|<>\\+=;,\\?\\*'@]*$").Success)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Name");
                    }
                    if (parameters.Description != null && parameters.Description.Length > 512)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Description");
                    }
                    if (parameters.BasePermissions == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.BasePermissions");
                    }
                }
            }
            RoleDefinition roleDefinition = new RoleDefinition(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            roleDefinition.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(roleDefinition.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, roleDefinition);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(roleDefinition);
            roleDefinition.InitFromCreationInformation(parameters);
            return(roleDefinition);
        }
        public User GetByLoginName(string loginName)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (loginName == null)
                {
                    throw ClientUtility.CreateArgumentNullException("loginName");
                }
                if (loginName != null && loginName.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("loginName");
                }
                if (loginName != null && loginName.Length > 251)
                {
                    throw ClientUtility.CreateArgumentException("loginName");
                }
            }
            object obj;
            Dictionary <string, User> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetByLoginName", out obj))
            {
                dictionary = (Dictionary <string, User>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, User>(StringComparer.OrdinalIgnoreCase);
                base.ObjectData.MethodReturnObjects["GetByLoginName"] = dictionary;
            }
            User user = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(loginName, out user))
            {
                return(user);
            }
            user = new User(context, new ObjectPathMethod(context, base.Path, "GetByLoginName", new object[]
            {
                loginName
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[loginName] = user;
            }
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(user.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, user);
            context.AddQuery(objectIdentityQuery);
            return(user);
        }
        public User GetByEmail(string emailAddress)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (emailAddress == null)
                {
                    throw ClientUtility.CreateArgumentNullException("emailAddress");
                }
                if (emailAddress != null && emailAddress.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("emailAddress");
                }
                if (emailAddress != null && emailAddress.Length > 255)
                {
                    throw ClientUtility.CreateArgumentException("emailAddress");
                }
            }
            object obj;
            Dictionary <string, User> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetByEmail", out obj))
            {
                dictionary = (Dictionary <string, User>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, User>();
                base.ObjectData.MethodReturnObjects["GetByEmail"] = dictionary;
            }
            User user = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(emailAddress, out user))
            {
                return(user);
            }
            user = new User(context, new ObjectPathMethod(context, base.Path, "GetByEmail", new object[]
            {
                emailAddress
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[emailAddress] = user;
            }
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(user.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, user);
            context.AddQuery(objectIdentityQuery);
            return(user);
        }
Пример #10
0
        public RoleDefinition GetByName(string name)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (name == null)
                {
                    throw ClientUtility.CreateArgumentNullException("name");
                }
                if (name != null && name.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("name");
                }
                if (name != null && name.Length > 255)
                {
                    throw ClientUtility.CreateArgumentException("name");
                }
            }
            object obj;
            Dictionary <string, RoleDefinition> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetByName", out obj))
            {
                dictionary = (Dictionary <string, RoleDefinition>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, RoleDefinition>();
                base.ObjectData.MethodReturnObjects["GetByName"] = dictionary;
            }
            RoleDefinition roleDefinition = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(name, out roleDefinition))
            {
                return(roleDefinition);
            }
            roleDefinition = new RoleDefinition(context, new ObjectPathMethod(context, base.Path, "GetByName", new object[]
            {
                name
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[name] = roleDefinition;
            }
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(roleDefinition.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, roleDefinition);
            context.AddQuery(objectIdentityQuery);
            return(roleDefinition);
        }
        public List GetByTitle(string title)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (title == null)
                {
                    throw ClientUtility.CreateArgumentNullException("title");
                }
                if (title != null && title.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("title");
                }
                if (title != null && title.Length > 255)
                {
                    throw ClientUtility.CreateArgumentException("title");
                }
            }
            object obj;
            Dictionary <string, List> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetByTitle", out obj))
            {
                dictionary = (Dictionary <string, List>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, List>(StringComparer.OrdinalIgnoreCase);
                base.ObjectData.MethodReturnObjects["GetByTitle"] = dictionary;
            }
            List list = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(title, out list))
            {
                return(list);
            }
            list = new List(context, new ObjectPathMethod(context, base.Path, "GetByTitle", new object[]
            {
                title
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[title] = list;
            }
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(list.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, list);
            context.AddQuery(objectIdentityQuery);
            return(list);
        }
Пример #12
0
        public void UnPublish(string comment)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient && comment != null && comment.Length > 1023)
            {
                throw ClientUtility.CreateArgumentException("comment");
            }
            ClientAction query = new ClientActionInvokeMethod(this, "UnPublish", new object[]
            {
                comment
            });

            context.AddQuery(query);
        }
Пример #13
0
        public Group Add(GroupCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Title == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Title");
                    }
                    if (parameters.Title != null && parameters.Title.Length == 0)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                    if (parameters.Title != null && parameters.Title.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                    if (parameters.Title != null && !Regex.Match(parameters.Title, "[^\\s\"/\\\\\\[\\]:|<>+=;,?*'@]+[^\"/\\\\\\[\\]:|<>+=;,?*'@]*").Success)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                    if (parameters.Description != null && parameters.Description.Length > 512)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Description");
                    }
                }
            }
            Group group = new Group(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            group.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(group.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, group);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(group);
            group.InitFromCreationInformation(parameters);
            return(group);
        }
        public User Add(UserCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.LoginName == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.LoginName");
                    }
                    if (parameters.LoginName != null && parameters.LoginName.Length == 0)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.LoginName");
                    }
                    if (parameters.LoginName != null && parameters.LoginName.Length > 251)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.LoginName");
                    }
                    if (parameters.Title != null && parameters.Title.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                    if (parameters.Email != null && parameters.Email.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Email");
                    }
                }
            }
            User user = new User(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            user.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(user.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, user);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(user);
            user.InitFromCreationInformation(parameters);
            return(user);
        }
        public ClientResult <string> GetValueForUICulture(string cultureName)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (cultureName == null)
                {
                    throw ClientUtility.CreateArgumentNullException("cultureName");
                }
                if (cultureName != null && cultureName.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("cultureName");
                }
            }
            object obj;
            Dictionary <string, ClientResult <string> > dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetValueForUICulture", out obj))
            {
                dictionary = (Dictionary <string, ClientResult <string> >)obj;
            }
            else
            {
                dictionary = new Dictionary <string, ClientResult <string> >();
                base.ObjectData.MethodReturnObjects["GetValueForUICulture"] = dictionary;
            }
            ClientResult <string> clientResult = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(cultureName, out clientResult))
            {
                return(clientResult);
            }
            ClientAction clientAction = new ClientActionInvokeMethod(this, "GetValueForUICulture", new object[]
            {
                cultureName
            });

            context.AddQuery(clientAction);
            clientResult = new ClientResult <string>();
            context.AddQueryIdAndResultObject(clientAction.Id, clientResult);
            if (!context.DisableReturnValueCache)
            {
                dictionary[cultureName] = clientResult;
            }
            return(clientResult);
        }
Пример #16
0
        public Field GetByTitle(string title)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (title == null)
                {
                    throw ClientUtility.CreateArgumentNullException("title");
                }
                if (title != null && title.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("title");
                }
            }
            object obj;
            Dictionary <string, Field> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetByTitle", out obj))
            {
                dictionary = (Dictionary <string, Field>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, Field>();
                base.ObjectData.MethodReturnObjects["GetByTitle"] = dictionary;
            }
            Field field = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(title, out field))
            {
                return(field);
            }
            field = new Field(context, new ObjectPathMethod(context, base.Path, "GetByTitle", new object[]
            {
                title
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[title] = field;
            }
            return(field);
        }
Пример #17
0
        public ContentType GetById(string contentTypeId)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (contentTypeId == null)
                {
                    throw ClientUtility.CreateArgumentNullException("contentTypeId");
                }
                if (contentTypeId != null && !Regex.Match(contentTypeId, "0x(([1-9a-fA-F][0-9a-fA-F])|(0[1-9a-fA-F]))*(00([0-9a-fA-F][0-9a-fA-F]){16})*").Success)
                {
                    throw ClientUtility.CreateArgumentException("contentTypeId");
                }
            }
            object obj;
            Dictionary <string, ContentType> dictionary;

            if (base.ObjectData.MethodReturnObjects.TryGetValue("GetById", out obj))
            {
                dictionary = (Dictionary <string, ContentType>)obj;
            }
            else
            {
                dictionary = new Dictionary <string, ContentType>();
                base.ObjectData.MethodReturnObjects["GetById"] = dictionary;
            }
            ContentType contentType = null;

            if (!context.DisableReturnValueCache && dictionary.TryGetValue(contentTypeId, out contentType))
            {
                return(contentType);
            }
            contentType = new ContentType(context, new ObjectPathMethod(context, base.Path, "GetById", new object[]
            {
                contentTypeId
            }));
            if (!context.DisableReturnValueCache)
            {
                dictionary[contentTypeId] = contentType;
            }
            return(contentType);
        }
        public ClientResult <string> ExportWebPart(Guid webPartId)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient && webPartId == Guid.Empty)
            {
                throw ClientUtility.CreateArgumentException("webPartId");
            }
            ClientAction clientAction = new ClientActionInvokeMethod(this, "ExportWebPart", new object[]
            {
                webPartId
            });

            context.AddQuery(clientAction);
            ClientResult <string> clientResult = new ClientResult <string>();

            context.AddQueryIdAndResultObject(clientAction.Id, clientResult);
            return(clientResult);
        }
Пример #19
0
        public File Add(FileCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Url == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Url");
                    }
                    Uri uri;
                    if (parameters.Url != null && !Uri.TryCreate(parameters.Url, UriKind.RelativeOrAbsolute, out uri))
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                    if (parameters.Url != null && parameters.Url.Length < 1)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Url");
                    }
                }
            }
            File file = new File(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            file.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(file.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, file);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(file);
            file.InitFromCreationInformation(parameters);
            return(file);
        }
        public WebPartDefinition AddWebPart(WebPart webPart, string zoneId, int zoneIndex)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (webPart == null)
                {
                    throw ClientUtility.CreateArgumentNullException("webPart");
                }
                if (zoneId == null)
                {
                    throw ClientUtility.CreateArgumentNullException("zoneId");
                }
                if (zoneId != null && zoneId.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("zoneId");
                }
                if (zoneId != null && zoneId.Length > 64)
                {
                    throw ClientUtility.CreateArgumentException("zoneId");
                }
                if (zoneIndex < 0)
                {
                    throw ClientUtility.CreateArgumentException("zoneIndex");
                }
            }
            WebPartDefinition webPartDefinition = new WebPartDefinition(context, new ObjectPathMethod(context, base.Path, "AddWebPart", new object[]
            {
                webPart,
                zoneId,
                zoneIndex
            }));

            webPartDefinition.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(webPartDefinition.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, webPartDefinition);
            context.AddQuery(objectIdentityQuery);
            return(webPartDefinition);
        }
Пример #21
0
        public ContentType Add(ContentTypeCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Name == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Name");
                    }
                    if (parameters.Group != null && parameters.Group.Length < 1)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Group");
                    }
                    if (parameters.Group != null && parameters.Group.Length > 128)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Group");
                    }
                }
            }
            ContentType contentType = new ContentType(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            contentType.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(contentType.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, contentType);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(contentType);
            contentType.InitFromCreationInformation(parameters);
            return(contentType);
        }
        public void RestoreByLabel(string versionlabel)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (versionlabel == null)
                {
                    throw ClientUtility.CreateArgumentNullException("versionlabel");
                }
                if (versionlabel != null && versionlabel.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("versionlabel");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "RestoreByLabel", new object[]
            {
                versionlabel
            });

            context.AddQuery(query);
        }
        public void MoveFieldTo(string field, int index)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (field == null)
                {
                    throw ClientUtility.CreateArgumentNullException("field");
                }
                if (index < 0)
                {
                    throw ClientUtility.CreateArgumentException("index");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "MoveFieldTo", new object[]
            {
                field,
                index
            });

            context.AddQuery(query);
        }
        public void SetValueForUICulture(string cultureName, string value)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (cultureName == null)
                {
                    throw ClientUtility.CreateArgumentNullException("cultureName");
                }
                if (cultureName != null && cultureName.Length == 0)
                {
                    throw ClientUtility.CreateArgumentException("cultureName");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "SetValueForUICulture", new object[]
            {
                cultureName,
                value
            });

            context.AddQuery(query);
        }
Пример #25
0
        public void CopyTo(string strNewUrl, bool bOverWrite)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (strNewUrl == null)
                {
                    throw ClientUtility.CreateArgumentNullException("strNewUrl");
                }
                Uri uri;
                if (strNewUrl != null && !Uri.TryCreate(strNewUrl, UriKind.RelativeOrAbsolute, out uri))
                {
                    throw ClientUtility.CreateArgumentException("strNewUrl");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "CopyTo", new object[]
            {
                strNewUrl,
                bOverWrite
            });

            context.AddQuery(query);
        }
Пример #26
0
        public void MoveTo(string newUrl, MoveOperations flags)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (newUrl == null)
                {
                    throw ClientUtility.CreateArgumentNullException("newUrl");
                }
                Uri uri;
                if (newUrl != null && !Uri.TryCreate(newUrl, UriKind.RelativeOrAbsolute, out uri))
                {
                    throw ClientUtility.CreateArgumentException("newUrl");
                }
            }
            ClientAction query = new ClientActionInvokeMethod(this, "MoveTo", new object[]
            {
                newUrl,
                flags
            });

            context.AddQuery(query);
        }
        public List Add(ListCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Title == null)
                    {
                        throw ClientUtility.CreateArgumentNullException("parameters.Title");
                    }
                    if (parameters.Title != null && parameters.Title.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                }
            }
            List list = new List(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            list.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(list.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, list);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(list);
            list.InitFromCreationInformation(parameters);
            return(list);
        }
        public View Add(ViewCreationInformation parameters)
        {
            ClientRuntimeContext context = base.Context;

            if (base.Context.ValidateOnClient)
            {
                if (parameters == null)
                {
                    throw ClientUtility.CreateArgumentNullException("parameters");
                }
                if (parameters != null)
                {
                    if (parameters.Title != null && parameters.Title.Length > 255)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.Title");
                    }
                    if (parameters.RowLimit > 2147483647u)
                    {
                        throw ClientUtility.CreateArgumentException("parameters.RowLimit");
                    }
                }
            }
            View view = new View(context, new ObjectPathMethod(context, base.Path, "Add", new object[]
            {
                parameters
            }));

            view.Path.SetPendingReplace();
            ObjectIdentityQuery objectIdentityQuery = new ObjectIdentityQuery(view.Path);

            context.AddQueryIdAndResultObject(objectIdentityQuery.Id, view);
            context.AddQuery(objectIdentityQuery);
            base.AddChild(view);
            view.InitFromCreationInformation(parameters);
            return(view);
        }