示例#1
0
        public async Task ShouldCreateObjectWithoutHelper()
        {
            /// Arrange
            var originalPlayer = new SoccerPlayer
            {
                BirthDate    = DateTime.Now,
                EmailAddress = "*****@*****.**",
                Firstname    = "Urs",
                LastName     = "Brogle"
            };

            /// Act
            var createRequest = new ListItemCreateRequest
            {
                ContentSchemaId = "SoccerPlayer",
                Content         = originalPlayer
            };

            var playerItem = await _client.ListItems.CreateAsync(createRequest);

            /// Assert
            Assert.NotNull(playerItem);

            var createdPlayer = playerItem.ConvertTo <SoccerPlayer>("SoccerPlayer");

            Assert.Equal("Urs", createdPlayer.Firstname);
        }
示例#2
0
        public async Task ShouldCreateObjectWithoutHelper()
        {
            // Arrange
            await SchemaHelper.CreateSchemasIfNotExistentAsync <Person>(_client).ConfigureAwait(false);

            var originalPlayer = new SoccerPlayer
            {
                BirthDate    = DateTime.Now,
                EmailAddress = "*****@*****.**",
                Firstname    = "Urs",
                LastName     = "Brogle"
            };

            // Act
            var createRequest = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(SoccerPlayer),
                Content         = originalPlayer
            };

            var playerItem = await _client.ListItem.CreateAsync(createRequest, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);

            // Assert
            Assert.NotNull(playerItem);

            var createdPlayer = playerItem.ConvertTo <SoccerPlayer>();

            Assert.Equal("Urs", createdPlayer.Firstname);
        }
示例#3
0
        private async Task ImportListItemsAsync(string schemaId, IList <PictureparkListItem> listItems)
        {
            try
            {
                var existingListItems = await GetListItemsAsync(schemaId);

                foreach (var listItem in listItems)
                {
                    var existingListItem = existingListItems.FirstOrDefault(existingListItemInner =>
                                                                            string.Equals(existingListItemInner.SmintIoKey, listItem.SmintIoKey));

                    if (existingListItem != null)
                    {
                        var listItemUpdateRequest = new ListItemUpdateRequest()
                        {
                            Content = listItem.Content
                        };

                        await _client.ListItem.UpdateAsync(existingListItem.PictureparkListItemId, listItemUpdateRequest);

                        listItem.SmintIoMetadataElement.TargetMetadataUuid = existingListItem.PictureparkListItemId;
                    }
                    else
                    {
                        var listItemCreateRequest = new ListItemCreateRequest()
                        {
                            Content         = listItem.Content,
                            ContentSchemaId = schemaId
                        };

                        var listItemDetail = await _client.ListItem.CreateAsync(listItemCreateRequest);

                        listItem.SmintIoMetadataElement.TargetMetadataUuid = listItemDetail.Id;
                    }
                }

                var noMoreExistingListItems = existingListItems.Where(existingListItemInner =>
                                                                      !listItems.Any(listItem => string.Equals(existingListItemInner.SmintIoKey, listItem.SmintIoKey)));

                foreach (var noMoreExistingListItem in noMoreExistingListItems)
                {
                    await _client.ListItem.DeleteAsync(noMoreExistingListItem.PictureparkListItemId);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error importing list items");

                throw;
            }
        }
示例#4
0
        public async Task ShouldBatchUpdateFieldsByFilter()
        {
            /// Arrange
            var objectName = "ThisObjectB" + new Random().Next(0, 999999);
            var listItem   = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(Tag),
                Content         = new Tag {
                    Name = objectName
                }
            };
            ListItemDetail listItemDetail = await _client.ListItems.CreateAsync(listItem);

            /// Act
            var updateRequest = new ListItemFieldsFilterUpdateRequest
            {
                ListItemFilterRequest = new ListItemFilterRequest                 // TODO: ListItemFieldsFilterUpdateRequest.ListItemFilterRequest: Rename property to FilterRequest?
                {
                    Filter = new TermFilter {
                        Field = "id", Term = listItemDetail.Id
                    }
                },
                ChangeCommands = new List <MetadataValuesChangeCommandBase>
                {
                    new MetadataValuesSchemaUpdateCommand
                    {
                        SchemaId = nameof(Tag),
                        Value    = new DataDictionary
                        {
                            { "name", "Foo" }
                        }
                    }
                }
            };

            /// Act
            var businessProcess = await _client.ListItems.BatchUpdateFieldsByFilterAsync(updateRequest);

            var waitResult = await _client.BusinessProcesses.WaitForCompletionAsync(businessProcess.Id, TimeSpan.FromSeconds(10));

            ListItemDetail result = await _client.ListItems.GetAsync(listItemDetail.Id, true);

            /// Assert
            Assert.Equal("Foo", result.ConvertTo <Tag>(nameof(Tag)).Name);
        }
示例#5
0
        public async Task ShouldCreate()
        {
            // Arrange
            var objectName = "ThisObjectB" + new Random().Next(0, 999999);
            var listItem   = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(Tag),
                Content         = new Tag {
                    Name = objectName
                }
            };

            // Act
            ListItemDetail result = await _client.ListItem.CreateAsync(listItem).ConfigureAwait(false);

            // Assert
            Assert.False(string.IsNullOrEmpty(result.Id));
        }
示例#6
0
        public async Task ShouldUpdateMany()
        {
            // Arrange
            await SchemaHelper.CreateSchemasIfNotExistentAsync <SoccerPlayer>(_client).ConfigureAwait(false);

            var originalPlayer = new SoccerPlayer
            {
                BirthDate    = DateTime.Now,
                EmailAddress = "*****@*****.**",
                Firstname    = "Test",
                LastName     = "Soccerplayer"
            };

            var createRequest = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(SoccerPlayer),
                Content         = originalPlayer
            };

            var playerItem = await _client.ListItem.CreateAsync(createRequest, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);

            // Act
            var player = playerItem.ConvertTo <SoccerPlayer>();

            player.Firstname = "xy jviorej ivorejvioe";

            await _client.ListItem.UpdateManyAsync(new ListItemUpdateManyRequest
            {
                AllowMissingDependencies = false,
                Items = new[]
                {
                    new ListItemUpdateItem()
                    {
                        Id = playerItem.Id, Content = player
                    }
                }
            }).ConfigureAwait(false);

            var updatedPlayer = await _client.ListItem.GetAndConvertToAsync <SoccerPlayer>(playerItem.Id, nameof(SoccerPlayer)).ConfigureAwait(false);

            // Assert
            Assert.Equal(player.Firstname, updatedPlayer.Firstname);
        }
示例#7
0
        public async Task ShouldBatchUpdateFieldsByFilter()
        {
            // Arrange
            var objectName = "ThisObjectB" + new Random().Next(0, 999999);
            var listItem   = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(Tag),
                Content         = new Tag {
                    Name = objectName
                }
            };
            ListItemDetail listItemDetail = await _client.ListItem.CreateAsync(listItem).ConfigureAwait(false);

            // Act
            var updateRequest = new ListItemFieldsBatchUpdateFilterRequest
            {
                FilterRequest = new ListItemFilterRequest
                {
                    Filter = new TermFilter {
                        Field = "id", Term = listItemDetail.Id
                    }
                },
                ChangeCommands = new List <MetadataValuesChangeCommandBase>
                {
                    new MetadataValuesSchemaUpdateCommand
                    {
                        SchemaId = nameof(Tag),
                        Value    = new DataDictionary
                        {
                            { "name", "Foo" }
                        }
                    }
                }
            };

            // Act
            await _client.ListItem.BatchUpdateFieldsByFilterAsync(updateRequest).ConfigureAwait(false);

            ListItemDetail result = await _client.ListItem.GetAsync(listItemDetail.Id, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);

            // Assert
            Assert.Equal("Foo", result.ConvertTo <Tag>().Name);
        }
示例#8
0
        public async Task ShouldUpdateMany()
        {
            /// Arrange
            var originalPlayer = new SoccerPlayer
            {
                BirthDate    = DateTime.Now,
                EmailAddress = "*****@*****.**",
                Firstname    = "Test",
                LastName     = "Soccerplayer"
            };

            var createRequest = new ListItemCreateRequest
            {
                ContentSchemaId = "SoccerPlayer",
                Content         = originalPlayer
            };

            var playerItem = await _client.ListItems.CreateAsync(createRequest);

            /// Act
            var player = playerItem.ConvertTo <SoccerPlayer>(nameof(SoccerPlayer));

            player.Firstname = "xy jviorej ivorejvioe";

            var businessProcess = await _client.ListItems.UpdateManyAsync(new ListItemUpdateManyRequest
            {
                AllowMissingDependencies = false,
                Requests = new[]
                {
                    new ListItemUpdateRequest {
                        Id = playerItem.Id, Content = player
                    }
                }
            });

            await _client.BusinessProcesses.WaitForCompletionAsync(businessProcess.Id);

            var updatedPlayer = await _client.ListItems.GetAndConvertToAsync <SoccerPlayer>(playerItem.Id, nameof(SoccerPlayer));

            /// Assert
            Assert.Equal(player.Firstname, updatedPlayer.Firstname);
        }
示例#9
0
        public async Task ShouldUpdate()
        {
            // Arrange
            await SchemaHelper.CreateSchemasIfNotExistentAsync <Person>(_client).ConfigureAwait(false);

            // Create object
            var objectName = "ObjectToUpdate" + new Random().Next(0, 999999);
            var listItem   = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(SoccerPlayer),
                Content         = new SoccerPlayer {
                    Firstname = objectName, LastName = "Foo", EmailAddress = "*****@*****.**"
                }
            };
            await _client.ListItem.CreateAsync(listItem).ConfigureAwait(false);

            // Search object
            var players = await _client.ListItem.SearchAsync(new ListItemSearchRequest
            {
                Limit        = 20,
                SearchString = objectName,
                SchemaIds    = new List <string> {
                    "SoccerPlayer"
                }
            }).ConfigureAwait(false);

            var playerObjectId = players.Results.First().Id;
            var playerItem     = await _client.ListItem.GetAsync(playerObjectId, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);

            // Act
            var player = playerItem.ConvertTo <SoccerPlayer>();

            player.Firstname = "xy jviorej ivorejvioe";

            await _client.ListItem.UpdateAsync(playerItem.Id, player).ConfigureAwait(false);

            var updatedPlayer = await _client.ListItem.GetAndConvertToAsync <SoccerPlayer>(playerItem.Id, nameof(SoccerPlayer)).ConfigureAwait(false);

            // Assert
            Assert.Equal(player.Firstname, updatedPlayer.Firstname);
        }
示例#10
0
        public async Task ShouldGetObject()
        {
            // Arrange
            var objectName = "ThisObjectC" + new Random().Next(0, 999999);

            // Act
            var createRequest = new ListItemCreateRequest
            {
                ContentSchemaId = nameof(Tag),
                Content         = new Tag {
                    Name = objectName
                }
            };

            var listItem = await _client.ListItem.CreateAsync(createRequest).ConfigureAwait(false);

            var result = await _client.ListItem.GetAsync(listItem.Id).ConfigureAwait(false);

            // Assert
            Assert.NotNull(result);
        }
示例#11
0
 /// <summary>Creates a <see cref="ListItemDetail"/>.</summary>
 /// <param name="createRequest">The create request.</param>
 /// <param name="resolve">Resolves the data of referenced list items into the contents's content.</param>
 /// <param name="allowMissingDependencies">Allow creating <see cref="ListItem"/>s that refer to list items or contents that don't exist in the system.</param>
 /// <param name="timeout">The timeout in milliseconds to wait for completion.</param>
 /// <param name="cancellationToken">The cancellation token.</param>
 /// <returns>The created <see cref="ListItemDetail"/>.</returns>
 /// <exception cref="ApiException">A server side error occurred.</exception>
 public async Task <ListItemDetail> CreateAsync(ListItemCreateRequest createRequest, bool resolve = false, bool allowMissingDependencies = false, TimeSpan?timeout = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await CreateAsync(createRequest, resolve, allowMissingDependencies, timeout, null, cancellationToken).ConfigureAwait(false));
 }