public async Task Should_create_singleton_schema()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto
{
Name = schemaName,
IsSingleton = true,
IsPublished = true
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// Should return created schemas with correct name.
Assert.Equal(schemaName, schema.Name);
// STEP 2: Get all schemas
var schemas = await _.Schemas.GetSchemasAsync(_.AppName);
// Should provide new schema when apps are schemas.
Assert.Contains(schemas.Items, x => x.Name == schemaName);
// STEP 3: Get singleton content
var client = _.ClientManager.CreateDynamicContentsClient(schemaName);
var content = await client.GetAsync(schema.Id);
Assert.NotNull(content);
}
public static CreateSchema ToCommand(this CreateSchemaDto dto)
{
var command = new CreateSchema();
SimpleMapper.Map(dto, command);
if (dto.Properties != null)
{
SimpleMapper.Map(dto.Properties, command.Properties);
}
if (dto.Fields != null)
{
foreach (var fieldDto in dto.Fields)
{
var fieldProperties = fieldDto?.Properties.ToProperties();
var fieldInstance = SimpleMapper.Map(fieldDto, new CreateSchemaField {
Properties = fieldProperties
});
command.Fields.Add(fieldInstance);
}
}
return(command);
}
public async Task <IActionResult> PostSchema(string app, [FromBody] CreateSchemaDto request)
{
var command = request.ToCommand();
var response = await InvokeCommandAsync(command);
return(CreatedAtAction(nameof(GetSchema), new { app, name = request.Name }, response));
}
public async Task <IActionResult> PostSchema(string app, [FromBody] CreateSchemaDto request)
{
var command = request.ToCommand();
await CommandBus.PublishAsync(command);
return(CreatedAtAction(nameof(GetSchema), new { name = request.Name }, new EntityCreatedDto {
Id = command.Name
}));
}
public async Task <IActionResult> PostSchema(string app, [FromBody] CreateSchemaDto request)
{
var command = request.ToCommand();
var context = await CommandBus.PublishAsync(command);
var result = context.Result <EntityCreatedResult <Guid> >();
var response = new EntityCreatedDto {
Id = command.SchemaId.ToString(), Version = result.Version
};
return(CreatedAtAction(nameof(GetSchema), new { name = request.Name }, response));
}
public async Task Should_not_allow_creation_if_name_used()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto {
Name = schemaName
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// STEP 2: Create again and fail
var ex = await Assert.ThrowsAnyAsync <SquidexManagementException>(() => _.Schemas.PostSchemaAsync(_.AppName, createRequest));
Assert.Equal(400, ex.StatusCode);
}
public async Task Should_update_singleton_content_with_special_id()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create singleton.
var createRequest = new CreateSchemaDto
{
Name = schemaName,
IsPublished = true,
IsSingleton = true,
Fields = new List <UpsertSchemaFieldDto>
{
new UpsertSchemaFieldDto
{
Name = "my-field",
Properties = new StringFieldPropertiesDto()
}
}
};
await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
var client = _.ClientManager.CreateDynamicContentsClient(schemaName);
// STEP 2: Get content.
var content_1 = await client.GetAsync("_schemaId_");
Assert.NotNull(content_1);
// STEP 3: Update content.
var content_2 = await client.UpdateAsync("_schemaId_", new DynamicData
{
["my-field"] = new JObject
{
["iv"] = "singleton"
}
});
Assert.Equal("singleton", content_2.Data["my-field"]["iv"]);
}
public async Task Should_create_app_with_anonymous_write_access()
{
var appName = Guid.NewGuid().ToString();
// STEP 1: Create app
var createRequest = new CreateAppDto {
Name = appName
};
var app = await _.Apps.PostAppAsync(createRequest);
// Should return create app with correct name.
Assert.Equal(appName, app.Name);
// STEP 2: Make the client anonymous.
var clientRequest = new UpdateClientDto {
AllowAnonymous = true
};
await _.Apps.PutClientAsync(appName, "default", clientRequest);
// STEP 3: Create schema
var schemaRequest = new CreateSchemaDto {
Name = "my-content", IsPublished = true
};
await _.Schemas.PostSchemaAsync(appName, schemaRequest);
// STEP 3: Create a content.
var url = $"{_.ClientManager.Options.Url}api/content/{appName}/my-content";
using (var httpClient = new HttpClient())
{
var response = await httpClient.PostAsync(url, new StringContent("{}", null, "text/json"));
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
}
public async Task Should_create_schema()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto {
Name = schemaName
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// Should return created schemas with correct name.
Assert.Equal(schemaName, schema.Name);
// STEP 2: Get all schemas
var schemas = await _.Schemas.GetSchemasAsync(_.AppName);
// Should provide new schema when apps are schemas.
Assert.Contains(schemas.Items, x => x.Name == schemaName);
}
public async Task Should_recreate_after_deleted()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto {
Name = schemaName
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// Should return created schemas with correct name.
Assert.Equal(schemaName, schema.Name);
// STEP 2: Delete schema.
await _.Schemas.DeleteSchemaAsync(_.AppName, schemaName);
// STEP 3: Create app again
await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
}
public async Task Should_create_schema_with_checkboxes()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto
{
Name = schemaName,
Fields = new List <UpsertSchemaFieldDto>
{
new UpsertSchemaFieldDto
{
Name = "references",
Partitioning = "invariant",
Properties = new ReferencesFieldPropertiesDto
{
Editor = ReferencesFieldEditor.Checkboxes
}
},
new UpsertSchemaFieldDto
{
Name = "tags",
Partitioning = "invariant",
Properties = new TagsFieldPropertiesDto
{
Editor = TagsFieldEditor.Checkboxes,
AllowedValues = new List <string> {
"value1"
}
}
}
}
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// Should return created schemas with correct name.
Assert.Equal(schemaName, schema.Name);
}
public async Task Should_delete_Schema()
{
var schemaName = $"schema-{Guid.NewGuid()}";
// STEP 1: Create schema
var createRequest = new CreateSchemaDto {
Name = schemaName
};
var schema = await _.Schemas.PostSchemaAsync(_.AppName, createRequest);
// Should return created schemas with correct name.
Assert.Equal(schemaName, schema.Name);
// STEP 2: Delete schema
await _.Schemas.DeleteSchemaAsync(_.AppName, schemaName);
var schemas = await _.Schemas.GetSchemasAsync(_.AppName);
// Should not provide deleted schema when schema are queried.
Assert.DoesNotContain(schemas.Items, x => x.Name == schemaName);
}
public async Task ImportAsync(DirectoryInfo directoryInfo, JsonHelper jsonHelper, SyncOptions options, ISession session)
{
var newSchemaNames =
GetSchemaFiles(directoryInfo)
.Select(x => jsonHelper.Read <SchemaModelNameOnly>(x, log))
.ToList();
if (!newSchemaNames.HasDistinctNames(x => x.Name))
{
log.WriteLine("ERROR: Can only sync schemas when all target schemas have distinct names.");
return;
}
var current = await session.Schemas.GetSchemasAsync(session.App);
var schemasByName = current.Items.ToDictionary(x => x.Name);
if (!options.NoDeletion)
{
foreach (var name in current.Items.Select(x => x.Name))
{
if (!newSchemaNames.Any(x => x.Name == name))
{
await log.DoSafeAsync($"Schema {name} deleting", async() =>
{
await session.Schemas.DeleteSchemaAsync(session.App, name);
});
}
}
}
foreach (var newSchema in newSchemaNames)
{
if (schemasByName.ContainsKey(newSchema.Name))
{
continue;
}
await log.DoSafeAsync($"Schema {newSchema.Name} creating", async() =>
{
var request = new CreateSchemaDto
{
Name = newSchema.Name
};
var created = await session.Schemas.PostSchemaAsync(session.App, request);
schemasByName[newSchema.Name] = created;
});
}
jsonHelper.SetSchemaMap(schemasByName.ToDictionary(x => x.Key, x => x.Value.Id));
var newSchemas =
GetSchemaFiles(directoryInfo)
.Select(x => jsonHelper.Read <SchemeModel>(x, log))
.ToList();
foreach (var newSchema in newSchemas)
{
var version = schemasByName[newSchema.Name].Version;
await log.DoVersionedAsync($"Schema {newSchema.Name} updating", version, async() =>
{
var result = await session.Schemas.PutSchemaSyncAsync(session.App, newSchema.Name, newSchema.Schema);
return(result.Version);
});
}
}
private async Task CreateSchemasAsync()
{
// STEP 1: Create cities schema.
var createCitiesRequest = new CreateSchemaDto
{
Name = "cities",
Fields = new List <UpsertSchemaFieldDto>
{
new UpsertSchemaFieldDto
{
Name = "name",
Properties = new StringFieldPropertiesDto()
}
},
IsPublished = true
};
var cities = await _.Schemas.PostSchemaAsync(_.AppName, createCitiesRequest);
// STEP 2: Create states schema.
var createStatesRequest = new CreateSchemaDto
{
Name = "states",
Fields = new List <UpsertSchemaFieldDto>
{
new UpsertSchemaFieldDto
{
Name = "name",
Properties = new StringFieldPropertiesDto()
},
new UpsertSchemaFieldDto
{
Name = "cities",
Properties = new ReferencesFieldPropertiesDto
{
SchemaIds = new List <string> {
cities.Id
}
}
}
},
IsPublished = true
};
var states = await _.Schemas.PostSchemaAsync(_.AppName, createStatesRequest);
// STEP 3: Create countries schema.
var createCountriesRequest = new CreateSchemaDto
{
Name = "countries",
Fields = new List <UpsertSchemaFieldDto>
{
new UpsertSchemaFieldDto
{
Name = "name",
Properties = new StringFieldPropertiesDto()
},
new UpsertSchemaFieldDto
{
Name = "states",
Properties = new ReferencesFieldPropertiesDto
{
SchemaIds = new List <string> {
states.Id
}
}
}
},
IsPublished = true
};
await _.Schemas.PostSchemaAsync(_.AppName, createCountriesRequest);
}
public async Task <IActionResult> Post([FromBody] CreateSchemaDto dto, CancellationToken cancellationToken)
{
var id = await _schemaService.CreateAsync(dto.Fields.ToEntities().ToList(), cancellationToken);
return(AcceptedAtAction(nameof(Get), new { id = id }, null));
}
