public static DogDto WithLinks(
this DogDto dogDto,
IUrlHelper urlHelper,
ApiVersion apiVersion)
{
dogDto.Links = new List <LinkDto>
{
new LinkDto(
urlHelper?.Link(
nameof(DogsController.GetDog),
new { id = dogDto.Id, version = apiVersion.ToString() }),
"self",
System.Net.Http.HttpMethod.Get.Method),
new LinkDto(
urlHelper?.Link(
nameof(DogsController.DeleteDog),
new { id = dogDto.Id, version = apiVersion.ToString() }),
"delete_dog",
System.Net.Http.HttpMethod.Delete.Method),
new LinkDto(
urlHelper?.Link(
nameof(DogsController.PutDog),
new { id = dogDto.Id, version = apiVersion.ToString() }),
"update_dog",
System.Net.Http.HttpMethod.Put.Method)
};
return(dogDto);
}
private IEnumerable <LinkDto> GetLinks(int id, ApiVersion version)
{
var links = new List <LinkDto>();
var getLink = _urlHelper.Link(nameof(GetSingleFood), new { version = version.ToString(), id = id });
links.Add(
new LinkDto(getLink, "self", "GET"));
var deleteLink = _urlHelper.Link(nameof(RemoveFood), new { version = version.ToString(), id = id });
links.Add(
new LinkDto(deleteLink,
"delete_food",
"DELETE"));
var createLink = _urlHelper.Link(nameof(AddFood), new { version = version.ToString() });
links.Add(
new LinkDto(createLink,
"create_food",
"POST"));
var updateLink = _urlHelper.Link(nameof(UpdateFood), new { version = version.ToString(), id = id });
links.Add(
new LinkDto(updateLink,
"update_food",
"PUT"));
return(links);
}
public void format_should_allow_null_or_empty_format_string(ApiVersionFormatProvider provider)
{
// arrange
var apiVersion = new ApiVersion(1, 0);
var expected = new[] { apiVersion.ToString(), apiVersion.ToString() };
// act
var actual = new[] { provider.Format(null, apiVersion, CurrentCulture), provider.Format(Empty, apiVersion, CurrentCulture) };
// assert
actual.Should().Equal(expected);
}
public async Task <IActionResult> Post([FromBody] AddProductCommand client, ApiVersion apiVersion,
CancellationToken token)
{
var entity = await _mediator.Send(client, token);
return(CreatedAtAction(nameof(Get), new { id = entity.Id, version = apiVersion.ToString() }, entity));
}
/// <summary>
/// Set <see cref="HttpRequestHeaders"/> using the <see cref="ApiHeaders"/>. This initially clears <paramref name="headers"/>
/// </summary>
/// <param name="headers">The <see cref="HttpRequestHeaders"/> to set</param>
/// <param name="instanceId">The <see cref="Models.Instance.Id"/> for the request</param>
public void SetRequestHeaders(HttpRequestHeaders headers, long?instanceId = null)
{
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
if (instanceId.HasValue && InstanceId.HasValue && instanceId != InstanceId)
{
throw new InvalidOperationException("Specified instance ID in constructor and SetRequestHeaders!");
}
headers.Clear();
headers.Accept.Add(new MediaTypeWithQualityHeaderValue(ApplicationJson));
if (IsTokenAuthentication)
{
headers.Authorization = new AuthenticationHeaderValue(JwtAuthenticationScheme, Token);
}
else
{
headers.Authorization = new AuthenticationHeaderValue(PasswordAuthenticationScheme, Password);
headers.Add(UsernameHeader, Username);
}
headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent));
headers.Add(ApiVersionHeader, new ProductHeaderValue(AssemblyName.Name, ApiVersion.ToString()).ToString());
instanceId = instanceId ?? InstanceId;
if (instanceId.HasValue)
{
headers.Add(InstanceIdHeader, instanceId.ToString());
}
}
private static NGitLab.Impl.ApiVersion VsApiVersionToNgitLabversion(ApiVersion apiVersion)
{
var result = NGitLab.Impl.ApiVersion.V4_Oauth;
Enum.TryParse(apiVersion.ToString(), out result);
return(result);
}
public async Task<IActionResult> CreateOrganization(CreateOrganizationCommand command, ApiVersion version)
{
var organization = await Mediator.Send(command);
return CreatedAtAction(nameof(GetOrganization),
new { id = organization.Id, version = version.ToString() },
organization);
}
public void AddVersionToRouteParameters([NotNull] IDictionary <string, object> routeValues)
{
if (!routeValues.ContainsKey(VersionRouteParameter))
{
routeValues.Add(VersionRouteParameter, ApiVersion.ToString(ApiVersionFormat));
}
}
/// <summary>
/// Set <see cref="HttpRequestHeaders"/> using the <see cref="ApiHeaders"/>. This initially clears <paramref name="headers"/>
/// </summary>
/// <param name="headers">The <see cref="HttpRequestHeaders"/> to set</param>
/// <param name="instanceId">The instance <see cref="Models.EntityId.Id"/> for the request</param>
public void SetRequestHeaders(HttpRequestHeaders headers, long?instanceId = null)
{
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
if (instanceId.HasValue && InstanceId.HasValue && instanceId != InstanceId)
{
throw new InvalidOperationException("Specified different instance IDs in constructor and SetRequestHeaders!");
}
headers.Clear();
headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
if (IsTokenAuthentication)
{
headers.Authorization = new AuthenticationHeaderValue(JwtAuthenticationScheme, Token);
}
else
{
headers.Authorization = new AuthenticationHeaderValue(
BasicAuthenticationScheme,
Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Username}:{Password}")));
}
headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent));
headers.Add(ApiVersionHeader, new ProductHeaderValue(AssemblyName.Name, ApiVersion.ToString()).ToString());
instanceId ??= InstanceId;
if (instanceId.HasValue)
{
headers.Add(InstanceIdHeader, instanceId.ToString());
}
}
/// <summary>
/// Adds the description for an API version expressed as a route parameter in a URL segment.
/// </summary>
protected virtual void UpdateUrlSegment()
{
var query = from description in ApiDescription.ParameterDescriptions
let routeInfo = description.RouteInfo
where routeInfo != null
let constraints = routeInfo.Constraints ?? Empty <IRouteConstraint>()
where constraints.OfType <ApiVersionRouteConstraint>().Any()
select description;
var parameter = query.FirstOrDefault();
if (parameter == null)
{
return;
}
parameter.IsRequired = true;
parameter.DefaultValue = ApiVersion.ToString();
parameter.ModelMetadata = ModelMetadata;
parameter.Type = ModelMetadata.ModelType;
parameter.RouteInfo.IsOptional = false;
parameter.RouteInfo.DefaultValue = parameter.DefaultValue;
if (parameter.ParameterDescriptor == null)
{
parameter.ParameterDescriptor = new ParameterDescriptor()
{
Name = parameter.Name,
ParameterType = typeof(ApiVersion),
};
}
RemoveAllParametersExcept(parameter);
}
public ActionResult PostDog(
[FromBody] DogDto dogDto,
ApiVersion apiVersion)
{
if (dogDto == null)
{
throw new BadRequestException(ErrorMessage.INVALID_REQUEST);
}
if (dogDto.ImageData != null && dogDto.ImageUrl != null)
{
throw new BadRequestException(ErrorMessage.TOO_MANY_IMAGES);
}
DogEntity dogEntity;
try
{
dogEntity = _dogMapper.ConvertToEntity(dogDto);
}
catch (System.FormatException)
{
throw new BadRequestException(ErrorMessage.INVALID_IMAGE);
}
dogEntity = _entityManager.AddDog(dogEntity);
_entityManager.Save();
return(CreatedAtRoute(
nameof(GetDog),
new { id = dogEntity.Id, version = apiVersion.ToString() },
_dogMapper.ConvertToDto(dogEntity, Url, apiVersion)));
}
ApiParameterDescription NewApiVersionParameter(string name, BindingSource source)
{
var parameter = new ApiParameterDescription()
{
DefaultValue = ApiVersion.ToString(),
IsRequired = !optional,
ModelMetadata = ModelMetadata,
Name = name,
ParameterDescriptor = new ParameterDescriptor()
{
Name = name,
ParameterType = typeof(ApiVersion),
},
Source = source,
Type = ModelMetadata.ModelType,
};
if (source == BindingSource.Path)
{
parameter.IsRequired = true;
parameter.RouteInfo = new ApiParameterRouteInfo()
{
DefaultValue = ApiVersion.ToString(),
IsOptional = false,
};
}
optional = true;
parameters.Add(parameter);
return(parameter);
}
public async Task <IActionResult> Post(ApiVersion apiVersion, [FromBody] PostOperacaoRequest model)
{
var operacaoGrupo = await _operacaoGrupoService.Get(model.OperacaoGrupoId);
if (operacaoGrupo == null)
{
ModelState.TryAddModelError(nameof(model.OperacaoGrupoId), "Código identificador do grupo de operação inválido.");
}
if (ModelState.IsValid)
{
var entity = model.ConvertRequestToEntity <Operacao>();
await _operacaoService.Create(entity);
await _unitOfWork.CompleteAsync();
return(CreatedAtAction(nameof(Get), new { version = apiVersion.ToString(), operacaoId = entity.Id }, new PostOperacaoResponse
{
Data = entity.ConvertEntityToSchema <OperacaoSchema>()
}));
}
return(BadRequest(ModelState.ToErrorResponse()));
}
public DogDto ConvertToDto(
DogEntity dogEntity,
IUrlHelper urlHelper,
ApiVersion apiVersion)
{
var dogDto = new DogDto
{
Id = dogEntity.Id,
Name = dogEntity.Name,
Breed = dogEntity.Breed,
};
if (dogEntity.ImageData != null)
{
dogDto.ImageUrl = urlHelper?.Link(
nameof(ImagesController.GetImage),
new
{
id = dogEntity.ImageData.Id,
extension = dogEntity.ImageData.Extension,
version = apiVersion.ToString()
});
}
else
{
dogDto.ImageUrl = dogEntity.ImageUrl;
}
return(dogDto.WithLinks(urlHelper, apiVersion));
}
public void GetFormattedApiVersionTest()
{
var version = new ApiVersion(1, 1);
ApiVersionDescription sut = new ApiVersionDescription(version, null, false);
sut.GetFormattedApiVersion().Should().Be($"v{version.ToString()}");
}
public async Task <IActionResult> SetupSession(
ApiVersion apiVersion,
[FromHeader(Name = Http.HeaderNames.AmsAuthor)] string author,
[FromHeader(Name = Http.HeaderNames.AmsAuthorLogin)] string authorLogin,
[FromHeader(Name = Http.HeaderNames.AmsAuthorName)] string authorName,
Language language,
long templateId)
{
if (string.IsNullOrEmpty(author) || string.IsNullOrEmpty(authorLogin) || string.IsNullOrEmpty(authorName))
{
return(BadRequest(
$"'{Http.HeaderNames.AmsAuthor}', '{Http.HeaderNames.AmsAuthorLogin}' and '{Http.HeaderNames.AmsAuthorName}' " +
"request headers must be specified."));
}
try
{
var sessionId = Guid.NewGuid();
await _sessionManagementService.Setup(sessionId, templateId, null, language, new AuthorInfo(author, authorLogin, authorName));
Response.Headers[HeaderNames.ETag] = $"\"{sessionId}\"";
var routeValues = new Dictionary <string, string> {
{ "api-version", apiVersion.ToString() }, { nameof(sessionId), sessionId.ToString() }
};
return(CreatedAtAction(nameof(Get), routeValues, null));
}
catch (ObjectNotFoundException ex)
{
return(NotFound(ex.Message));
}
catch (SessionCannotBeCreatedException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Post([FromBody] TaskSubjectCreateModel model, ApiVersion apiVersion)
{
_logger.LogInformation(MyLogEvents.TaskSubjectControllerPost, "Get Request is Valid");
var id = await _taskSubjectFacade.CreateTaskSubjectAsync(_mapper.Map <TaskSubjectDto>(model));
_logger.LogInformation(MyLogEvents.TaskSubjectControllerPost, "Created Object with internal id {id}", id);
return(CreatedAtAction(nameof(Get), new { id = model.Uid, version = apiVersion.ToString() }, model));
}
/// <summary>
/// Adds the description for an API version expressed as a media type parameter.
/// </summary>
/// <param name="name">The name of the media type parameter.</param>
protected virtual void AddMediaTypeParameter(string name)
{
var parameter = new NameValueHeaderValue(name, ApiVersion.ToString());
CloneFormattersAndAddMediaTypeParameter(parameter, ApiDescription.SupportedRequestBodyFormatters);
CloneFormattersAndAddMediaTypeParameter(parameter, ApiDescription.SupportedResponseFormatters);
parameters.Add(NewApiVersionParameter(name, Unknown, allowOptional: false));
}
public void ConfigureServices(IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
services.AddControllers();
var defaultApiVersion = new ApiVersion(1, 0);
services.AddApiVersioning(o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.DefaultApiVersion = defaultApiVersion;
})
.AddVersionedApiExplorer(o =>
{
o.GroupNameFormat = "'v'VVV";
o.SubstituteApiVersionInUrl = true;
})
.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = $"Tester Admin API {defaultApiVersion}",
Version = defaultApiVersion.ToString()
});
});
services.AddEntityFrameworkNpgsql()
.AddDbContext <TesterDbContext>((sp, ob) =>
{
ob.UseNpgsql(_configuration.GetConnectionString("Postgres"));
if (_loggerFactory != null)
{
ob.UseLoggerFactory(_loggerFactory);
}
})
.AddScoped <ResetDbContext>(x => x.GetService <TesterDbContext>())
.AddScoped <IDataProvider, EfDataProvider>()
.AddScoped <IRoDataProvider>(x => x.GetService <IDataProvider>())
.AddScoped <IModelStore, TesterDbModelStore>()
.AddScoped <IAsyncHelpers, EfAsyncHelpers>()
.AddScoped <IDataExceptionManager, PostgresDbExceptionManager>()
.AddScoped <IIndexProvider, PostgresIndexProvider>();
services.AddScoped <IRoleRoService, RoleRoService>();
services.AddScoped <IFilterHelper, FilterHelper>();
services.AddScoped <IExpressionHelper, ExpressionHelper>();
services.AddScoped <IOrderHelper, OrderHelper>();
services.AddScoped <IAuthService, AuthService>();
services.AddScoped <IPasswordProvider, PasswordProvider>();
services.AddScoped <ITokenProvider, EmptyTokenProvider>();
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
}
private IEnumerable <LinkDto> GetLinks(int id, ApiVersion version)
{
var links = new List <LinkDto>();
var getLink = _urlHelper.Link(nameof(GetSingleShip), new { version = version.ToString(), id = id });
links.Add(
new LinkDto(getLink, "self", "GET"));
var createLink = _urlHelper.Link(nameof(AddShip), new { version = version.ToString() });
links.Add(
new LinkDto(createLink,
"create_ship",
"POST"));
return(links);
}
/// <summary>
/// Adds the description for an API version expressed as a media type parameter.
/// </summary>
/// <param name="name">The name of the media type parameter.</param>
protected virtual void AddMediaTypeParameter(string name)
{
Arg.NotNullOrEmpty(name, nameof(name));
var parameter = new NameValueHeaderValue(name, ApiVersion.ToString());
CloneFormattersAndAddMediaTypeParameter(parameter, ApiDescription.SupportedRequestBodyFormatters);
CloneFormattersAndAddMediaTypeParameter(parameter, ApiDescription.SupportedResponseFormatters);
}
static IRouteConstraint MakeVersionedODataRouteConstraint(ApiVersion apiVersion, ref string versionedRouteName)
{
if (apiVersion == null)
{
return(new ODataPathRouteConstraint(versionedRouteName));
}
versionedRouteName += "-" + apiVersion.ToString();
return(new VersionedODataPathRouteConstraint(versionedRouteName, apiVersion));
}
public async Task <ActionResult <CreateUserDto> > CreateUser(
CreateUserCommand createUserCommand,
ApiVersion version)
{
var applicationUser = await Mediator.Send(createUserCommand);
var routeValues = new { slug = applicationUser.Slug, version = version.ToString() };
return(CreatedAtAction(nameof(GetBySlug), routeValues, applicationUser));
}
private List <LinkDto> CreateLinksForCollection(QueryParameters queryParameters, int totalCount, ApiVersion version)
{
var links = new List <LinkDto>();
// self
links.Add(new LinkDto(_urlHelper.Link(nameof(GetAllFoods), new
{
pagecount = queryParameters.PageCount,
page = queryParameters.Page,
orderby = queryParameters.OrderBy
}), "self", "GET"));
links.Add(new LinkDto(_urlHelper.Link(nameof(GetAllFoods), new
{
pagecount = queryParameters.PageCount,
page = 1,
orderby = queryParameters.OrderBy
}), "first", "GET"));
links.Add(new LinkDto(_urlHelper.Link(nameof(GetAllFoods), new
{
pagecount = queryParameters.PageCount,
page = queryParameters.GetTotalPages(totalCount),
orderby = queryParameters.OrderBy
}), "last", "GET"));
if (queryParameters.HasNext(totalCount))
{
links.Add(new LinkDto(_urlHelper.Link(nameof(GetAllFoods), new
{
pagecount = queryParameters.PageCount,
page = queryParameters.Page + 1,
orderby = queryParameters.OrderBy
}), "next", "GET"));
}
if (queryParameters.HasPrevious())
{
links.Add(new LinkDto(_urlHelper.Link(nameof(GetAllFoods), new
{
pagecount = queryParameters.PageCount,
page = queryParameters.Page - 1,
orderby = queryParameters.OrderBy
}), "previous", "GET"));
}
var posturl = _urlHelper.Link(nameof(AddFood), new { version = version.ToString() });
links.Add(
new LinkDto(posturl,
"create_food",
"POST"));
return(links);
}
public async Task <IActionResult> Post(ProductRequest req, ApiVersion ver)
{
Validate(req);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _productRepository.Create(req);
return(CreatedAtRoute(nameof(GetById), new { id = result.Id, version = ver.ToString() }, result));
}
public async Task <IActionResult> Create(ApiVersion apiVersion, [FromBody] CreateProductRequest model)
{
if (ModelState.IsValid)
{
var command = _mapper.ConvertRequestToCommand <CreateProductCommand>(model);
var result = await _mediator.Send(command);
return(CreatedAtAction(nameof(Get), new { version = apiVersion.ToString(), sku = result.Sku }, result));
}
return(BadRequest(ModelState.ToErrorResponse()));
}
public async Task <IActionResult> InsertMovie([FromBody] MovieViewModel model, ApiVersion apiVersion)
{
var(isSuccess, id) = await _service.InsertAsync(model);
if (isSuccess)
{
return(CreatedAtAction(nameof(GetMovie), new { id, version = apiVersion.ToString() }, id));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> Post(ApiVersion apiVersion, [FromBody] PostOperacaoGrupoRequest model)
{
var entity = model.ConvertRequestToEntity <OperacaoGrupo>();
await _operacaoGrupoService.Create(entity);
await _unitOfWork.CompleteAsync();
return(CreatedAtAction(nameof(Get), new { version = apiVersion.ToString(), operacaoGrupoId = entity.Id }, new PostOperacaoGrupoResponse
{
Data = entity.ConvertEntityToSchema <OperacaoGrupoSchema>()
}));
}
static IRouteConstraint MakeVersionedODataRouteConstraint(ApiVersion apiVersion, ref string versionedRouteName)
{
Contract.Requires(!IsNullOrEmpty(versionedRouteName));
Contract.Ensures(Contract.Result <IRouteConstraint>() != null);
if (apiVersion == null)
{
return(new ODataPathRouteConstraint(versionedRouteName));
}
versionedRouteName += "-" + apiVersion.ToString();
return(new VersionedODataPathRouteConstraint(versionedRouteName, apiVersion));
}
public async Task <IActionResult> CreateLicenseAsync(
[FromBody] CreateLicenseRequest createLicense, ApiVersion version, CancellationToken token)
{
var createdLicense = await _licenseInstructor.CreateAsync(createLicense.ToDto(), token);
var routeValues = new
{
version = version.ToString(),
licenseId = createdLicense.LicenseId
};
return(CreatedAtAction(nameof(GetLicenseIdAsync), routeValues, createdLicense));
}
public static string GetTextForApiVersion(ApiVersion apiVersion)
{
return Lang.ResourceManager.GetString("ApiVersion_" + apiVersion.ToString(), Lang.Culture);
}
