Esempio n. 1
0
        public async Task Existing_list_is_not_added()
        {
            ClientContext.Load(Web, w => w.ServerRelativeUrl);

            var list = await CreateList(
                l => l.Title,
                l => l.RootFolder.ServerRelativeUrl
                );

            var prov = new HarshList()
            {
                Title = list.Title,
                Url   = HarshUrl.GetRelativeTo(list.RootFolder.ServerRelativeUrl, Web.ServerRelativeUrl),
            };

            await prov.ProvisionAsync(Context);

            var output = LastObjectOutput <List>();

            Assert.False(output.ObjectAdded);

            var outputList = output.Object;

            Assert.NotNull(outputList);

            ClientContext.Load(
                outputList,
                l => l.Title
                );

            await ClientContext.ExecuteQueryAsync();

            Assert.Equal(list.Title, outputList.Title);
        }
Esempio n. 2
0
        protected override String GetIdentifier(List result)
        {
            if (result == null)
            {
                throw Logger.Fatal.ArgumentNull(nameof(result));
            }

            return(HarshUrl.GetRelativeTo(result.RootFolder.ServerRelativeUrl, result.ParentWebUrl));
        }
Esempio n. 3
0
        private async Task <String> EnsureServerRelativeOrNull(String url)
        {
            if (url == null)
            {
                return(null);
            }

            return(await HarshUrl.EnsureServerRelative(Site, url));
        }
Esempio n. 4
0
        protected override async Task InitializeAsync()
        {
            await base.InitializeAsync();

            PackageUrl = await HarshUrl.EnsureServerRelative(CatalogFolder.Value, DesignPackageName);

            PackageInfo = new DesignPackageInfo()
            {
                PackageName = DesignPackageName,
            };
        }
Esempio n. 5
0
        protected override async Task OnProvisioningAsync()
        {
            var fci = new FileCreationInformation()
            {
                ContentStream = ContentStream,
                Overwrite     = OverwriteExisting,
                Url           = await HarshUrl.EnsureServerRelative(Folder.Value, FileName),
            };

            AddedFile = Folder.Value.Files.Add(fci);
            await ClientContext.ExecuteQueryAsync();
        }
        protected override String GetIdentifierFromNested(NestedResolveResult nested)
        {
            if (nested == null)
            {
                throw Logger.Fatal.ArgumentNull(nameof(nested));
            }

            var tuple = nested.ExtractComponents <List, View>();

            return(HarshUrl.GetRelativeTo(
                       tuple.Item2.ServerRelativeUrl,
                       tuple.Item1.RootFolder.ServerRelativeUrl
                       ));
        }
Esempio n. 7
0
        public async Task List_gets_resolved_by_url()
        {
            ClientContext.Load(Web, w => w.ServerRelativeUrl);
            var list = await CreateList(l => l.RootFolder.ServerRelativeUrl);

            var url = HarshUrl.GetRelativeTo(list.RootFolder.ServerRelativeUrl, Web.ServerRelativeUrl);

            var results = ManualResolver.Resolve(
                Resolve.List().ByUrl(url)
                );

            await ClientContext.ExecuteQueryAsync();

            var resolvedList = Assert.Single(results);

            Assert.NotNull(resolvedList);
            Assert.Equal(
                list.RootFolder.ServerRelativeUrl,
                resolvedList.RootFolder.ServerRelativeUrl,
                StringComparer.OrdinalIgnoreCase
                );
        }