public async Task <ProviderDto> CreateAsync(NewProviderDto provider)
{
var model = _mapper.Map <NewProviderDto, Provider>(provider);
await _uow.ProviderRepository.AddAsync(model);
await _uow.CommitAsync();
return(_mapper.Map <Provider, ProviderDto>(model));
}
public async void RegisterProvider_ReturnsCreatedProvider()
{
_pluginService
.Setup(s => s.AddPlugin(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string[]>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((string name, string type, string author, string version, string[] requiredServices, CancellationToken cancellationToken) =>
new Plugin
{
Id = 1,
Name = name,
Type = type,
Author = author,
Version = version,
RequiredServicesString = string.Join(",", requiredServices)
});
_pluginAdditionalConfigService.Setup(s => s.AddAdditionalConfigs(It.IsAny <int>(), It.IsAny <List <PluginAdditionalConfig> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <int> {
1
});
var controller = new ProviderController(_pluginService.Object, _pluginAdditionalConfigService.Object, _mapper, _logger.Object);
var dto = new NewProviderDto
{
Name = "AspMvcNet",
Type = "GeneratorProvider",
Author = "polyrific",
Version = "1.0.0",
RequiredServices = new string[] { "test" }
};
var result = await controller.RegisterProvider(dto);
var createAtRouteActionResult = Assert.IsType <CreatedAtRouteResult>(result);
var returnValue = Assert.IsType <ProviderDto>(createAtRouteActionResult.Value);
Assert.Equal(1, returnValue.Id);
Assert.Equal("AspMvcNet", returnValue.Name);
Assert.Equal("GeneratorProvider", returnValue.Type);
Assert.Equal("polyrific", returnValue.Author);
Assert.Equal("1.0.0", returnValue.Version);
Assert.NotEmpty(returnValue.RequiredServices);
}
public void ProviderRegister_Execute_ReturnsSuccessMessage()
{
var testFile = Path.Combine(AppContext.BaseDirectory, "providerTest.yaml");
if (File.Exists(testFile))
{
File.Delete(testFile);
}
var testContent = new NewProviderDto
{
Name = "AProvider01",
Type = PluginType.HostingProvider,
Author = "Frandi",
Version = "1.0"
};
var stringContent = YamlSerialize(testContent);
File.WriteAllText(testFile, stringContent);
_providerService.Setup(s => s.AddProvider(It.IsAny <NewProviderDto>())).ReturnsAsync((NewProviderDto dto) => new ProviderDto
{
Id = 1,
Name = dto.Name,
Type = dto.Type,
Author = dto.Author,
Version = dto.Version
});
var command = new RegisterCommand(_providerService.Object, _console, LoggerMock.GetLogger <RegisterCommand>().Object)
{
MetadataFile = testFile
};
var message = command.Execute();
Assert.Equal("Task provider AProvider01 (v1.0) by Frandi has been registered successfully.", message);
}
public async Task <IActionResult> RegisterProvider(NewProviderDto dto)
{
_logger.LogInformation("Registering provider. Request body: {@dto}", dto);
try
{
var plugin = await _pluginService.AddPlugin(dto.Name, dto.Type, dto.Author, dto.Version, dto.RequiredServices);
var result = _mapper.Map <ProviderDto>(plugin);
if (dto.AdditionalConfigs != null && dto.AdditionalConfigs.Length > 0)
{
var additionalConfigs = _mapper.Map <List <PluginAdditionalConfig> >(dto.AdditionalConfigs);
var _ = await _pluginAdditionalConfigService.AddAdditionalConfigs(plugin.Id, additionalConfigs);
}
return(CreatedAtRoute("GetProviderById", new { providerId = plugin.Id }, result));
}
catch (RequiredServicesNotSupportedException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> CreateProvider(NewProviderDto provider)
{
try
{
if (provider.Location == provider.Name)
{
ModelState.AddModelError(
"Location",
"The provider description should be different from rhe name!");
}
if (await _providerService.ProvidersExistsAsync(provider.Name))
{
ModelState.AddModelError(
"Name",
"A provider with the same name already exists into the database!");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var insertedProvider = await _providerService.CreateAsync(provider);
if (insertedProvider == null)
{
return(Problem());
}
return(CreatedAtRoute("GetProvider", new { id = insertedProvider.Id }, insertedProvider));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Failed to succeed the operation!"));
}
}
private string YamlSerialize(NewProviderDto dto)
{
var serializer = new SerializerBuilder().WithNamingConvention(new HyphenatedNamingConvention()).Build();
return(serializer.Serialize(dto));
}
public async Task <ProviderDto> AddProvider(NewProviderDto dto)
{
var path = "provider";
return(await Api.Post <NewProviderDto, ProviderDto>(path, dto));
}
