public async Task ShouldUseDisplayLanguageToResolveDisplayValues()
{
// Arange
var schema = await SchemaHelper.CreateSchemasIfNotExistentAsync <DisplayLanguageTestItems>(_client).ConfigureAwait(false);
var listItem1 = new DisplayLanguageTestItems()
{
Value1 = "value1",
Value2 = "value2"
};
var detail = await _client.ListItem.CreateAsync(new ListItemCreateRequest()
{
ContentSchemaId = schema.Id, Content = listItem1
}).ConfigureAwait(false);
// Act
var englishClient = _fixture.GetLocalizedPictureparkService("en");
var receivedItem1 = await englishClient.ListItem.GetAsync(detail.Id, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);
var germanClient = _fixture.GetLocalizedPictureparkService("de");
var receivedItem2 = await germanClient.ListItem.GetAsync(detail.Id, new[] { ListItemResolveBehavior.Content }).ConfigureAwait(false);
// Assert
receivedItem1.DisplayValues[DisplayPatternType.Name.ToString().ToLowerCamelCase()].Should().Be("value2");
receivedItem2.DisplayValues[DisplayPatternType.Name.ToString().ToLowerCamelCase()].Should().Be("value1");
}
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);
}
public async Task ShouldCreateSchemaAndValidateMaxRecursion()
{
// Act
var schema = await SchemaHelper.CreateSchemasIfNotExistentAsync <Person>(_client).ConfigureAwait(false);
// Assert
Assert.Contains(schema.Types, i => i == SchemaType.List || i == SchemaType.Struct);
}
public async Task ShouldUseLocalDateForDisplayValue()
{
// Arange
await SchemaHelper.CreateSchemasIfNotExistentAsync <LocalDateTestItem>(_client).ConfigureAwait(false);
var date = new DateTime(2012, 12, 12, 1, 1, 1).ToUniversalTime();
var listItem1 = new LocalDateTestItem
{
DateTimeField = date,
Child = new LocalDateTestItem
{
DateTimeField = new DateTime(2010, 1, 1, 12, 1, 1)
}
};
var detail = await _client.ListItem.CreateFromObjectAsync(listItem1).ConfigureAwait(false);
var details = await detail.FetchDetail(new[] { ListItemResolveBehavior.Content, ListItemResolveBehavior.InnerDisplayValueName }).ConfigureAwait(false);
var items = details.SucceededItems;
// Act
var item = items.Last();
var dateValue = item.ConvertTo <LocalDateTestItem>().DateTimeField;
const string quote = "\"";
var shouldBeValue = $"{{{{ {quote}{dateValue:s}Z{quote} | date: {quote}%d.%m.%Y %H:%M:%S{quote} }}}}";
// Assert
item.DisplayValues[DisplayPatternType.Name.ToString().ToLowerCamelCase()]
.Should().Be(shouldBeValue);
var renderedDisplayValue = LocalizationService.GetDateTimeLocalizedDisplayValue(shouldBeValue);
var formattedLocalDate = date.ToLocalTime().ToString("dd.MM.yyyy HH:mm:ss");
var formattedChildLocalDate = listItem1.Child.DateTimeField.ToString("dd.MM.yyyy HH:mm:ss");
renderedDisplayValue.Should().Be(formattedLocalDate);
// Apply local time to object tree
LocalizationService.ReplaceDateTimeLocalizedDisplayValueInObject(item);
item.DisplayValues["name"].Should().Be(formattedLocalDate);
((JObject)item.Content)
.GetValue("child")
.Value <JToken>("displayValue")
.Value <string>("name").Should()
.Be(formattedChildLocalDate);
}
public async Task ShouldCreateSchemaAndValidateMultiline()
{
// Arrange
await SchemaHelper.CreateSchemasIfNotExistentAsync <Person>(_client).ConfigureAwait(false);
string expectedMultilineString = "\"multiLine\":true";
// Act
var generatedSoccerPlayerSchema = await _client.Schema.GetAsync("Person").ConfigureAwait(false);
var jsonConvertedField = generatedSoccerPlayerSchema.Fields.ToList()[0];
// Assert
Assert.Contains(expectedMultilineString, JsonConvert.SerializeObject(jsonConvertedField));
}
public async Task ShouldCreateSchemaAndValidateFilter()
{
// Arrange
await SchemaHelper.CreateSchemasIfNotExistentAsync <SoccerPlayer>(_client).ConfigureAwait(false);
var expectedFilterString = "{\"kind\":\"TermFilter\",\"field\":\"contentType\",\"term\":\"FC Aarau\"}";
// Act
var generatedSoccerPlayerSchema = await _client.Schema.GetAsync("SoccerPlayer").ConfigureAwait(false);
var jsonConvertedField = generatedSoccerPlayerSchema.Fields.Single(i => i.Id == "club");
// Assert
Assert.Contains(expectedFilterString, JsonConvert.SerializeObject(jsonConvertedField));
}
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);
}
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);
}
public async Task ShouldProperlyResolveSchemaName()
{
// Arrange
await SchemaHelper.CreateSchemasIfNotExistentAsync <Vehicle>(_client).ConfigureAwait(false);
var carResult = await _client.ListItem.CreateFromObjectAsync(
new Car
{
NumberOfWheels = 4,
HorsePower = 142,
BootSize = 490,
Model = "Civic",
Introduced = new DateTime(2013, 1, 1)
}).ConfigureAwait(false);
var carResultDetail = await carResult.FetchDetail().ConfigureAwait(false);
carResultDetail.FailedItems.Should().BeEmpty();
carResultDetail.SucceededItems.Should().NotBeEmpty()
.And.Subject.First().ContentSchemaId.Should().Be("Automobile");
}
public async Task ShouldCreateComplexObjectWithHelper()
{
// Arrange
await SchemaHelper.CreateSchemasIfNotExistentAsync <Person>(_client).ConfigureAwait(false);
// Reusable as reference
var dog = new Dog
{
Name = "Dogname1",
PlaysCatch = true
};
// Act
// Using Helper method
var soccerPlayerResult = await _client.ListItem.CreateFromObjectAsync(
new SoccerPlayer
{
BirthDate = DateTime.Now,
EmailAddress = "*****@*****.**",
Firstname = "Urxxxxs",
LastName = "xxxxxxxx",
Addresses = new List <Addresses>
{
new Addresses
{
Name = "Aarau",
SecurityPet = dog
}
},
OwnsPets = new List <Pet>
{
new Cat
{
Name = "Catname1",
ChasesLaser = true
},
dog
}
}).ConfigureAwait(false);
var soccerPlayerDetail = await soccerPlayerResult.FetchDetail().ConfigureAwait(false);
var soccerTrainerResult = await _client.ListItem.CreateFromObjectAsync(
new SoccerTrainer
{
BirthDate = DateTime.Now,
EmailAddress = "*****@*****.**",
Firstname = "Urxxxxs",
LastName = "xxxxxxxx",
TrainerSince = new DateTime(2000, 1, 1)
}).ConfigureAwait(false);
var soccerTrainerDetail = await soccerTrainerResult.FetchDetail().ConfigureAwait(false);
var personResult = await _client.ListItem.CreateFromObjectAsync(
new Person
{
BirthDate = DateTime.Now,
EmailAddress = "*****@*****.**",
Firstname = "Urxxxxs",
LastName = "xxxxxxxx"
}).ConfigureAwait(false);
var personDetail = await personResult.FetchDetail().ConfigureAwait(false);
// Assert
soccerPlayerDetail.SucceededItems.Should().NotBeEmpty();
soccerTrainerDetail.SucceededItems.Should().NotBeEmpty();
personDetail.SucceededItems.Should().NotBeEmpty();
}