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); }