public IRestEndpoint GetFromResource(IEndpointContext endpointContext, [NotNull] IRestResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
switch (resource)
{
case IRestCollection collection:
return(new RestCollectionEndpoint(endpointContext, collection));
case IRestItem item:
return(new RestItemEndpoint(endpointContext, item));
case IRestScalar scalar:
return(new RestScalarEndpoint(endpointContext, scalar));
case IRestDictionary dictionary:
return(new RestDictionaryEndpoint(endpointContext, dictionary));
case IRestDirectory directory:
return(new RestDirectoryEndpoint(endpointContext, directory));
default:
throw new IncorrectResourceTypeException(resource.GetType());
}
}
public override async Task <TResponse> GetAsync <TResponse>(IRestResource <BitBucketClientContext> resource, BitBucketClientContext context)
{
var url = this.BuildUri(context, () => resource.GetResourceUrl(context));
var response = await this.GetAsync(url.Uri).ConfigureAwait(false);
return(await response.DeserializeAsync <TResponse>().ConfigureAwait(false));
}
public IRestResource GetField(string fieldName)
{
if (!_context.Fields.FieldExists(fieldName))
{
throw new FieldNotFoundException(fieldName, true);
}
var namedField = new NamedField <TItem>(fieldName, _context.Fields);
if (!_context.AuthorizationChecker.CanGetField(_item, namedField))
{
throw new NotAuthorizedForFieldException(AuthorizableVerb.Get, fieldName);
}
IRestResource fullResource = _context.Fields.GetFullResource(fieldName, _item, _context.Transaction);
if (fullResource != null)
{
return(fullResource);
}
if (ScalarFieldHelper.IsScalarType(namedField.Reader.FieldType))
{
return(new EngineRestScalar <TItem>(_context, _item, namedField));
}
return(new EngineRestPoco <TItem>(_context, _item, namedField));
}
public IRestEndpoint Next(INextPath resourceName)
{
IRestResource resource = Directory.GetChild(resourceName.GetCoded());
if (resource == null)
{
return(null);
}
return(Context.Services.EndpointResolver.GetFromResource(Context, resource));
}
public IRestEndpoint GetEndpointFromPath(string resourcePath)
{
IRestResource startResource = _startResourceFactory.GetStartResource(_requestContext);
var context = new EndpointContext(_requestContext, _services);
IRestEndpoint startEndpoint = _services.EndpointResolver.GetFromResource(context, startResource);
var nextAggregator = new NextAggregator(startEndpoint, _services.NameSwitcher ?? new VoidNamingConventionSwitcher());
IRestEndpoint endpoint = nextAggregator.AggregateNext(resourcePath);
//var wrappedEndpoint = new NamingSwitcherEndpointWrapper(endpoint, namingConventionSwitcher);
return(endpoint);
}
private static IRestItem AsItem([NotNull] this IRestResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (resource is IRestItem item)
{
return(item);
}
throw new ArgumentException("Resource was not an item.", nameof(resource));
}
private static IRestScalar AsScalar([NotNull] this IRestResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (resource is IRestScalar scalar)
{
return(scalar);
}
throw new ArgumentException("Resource was not a scalar.", nameof(resource));
}
protected async Task <IRestActionResult> ExecuteAsync(IRestAction action, IRestResource resource = null)
{
try {
resource = resource ?? DefaultResource;
var context = new RestActionExecutionContext(ClientSettings, resource, _httpClient);
return(await action.ExecuteAsync(context));
}
catch (Exception ex) {
var(actionName, request) = action.ToLogInfo();
await Log.WriteErrorAsync(GetType().Name, actionName, request, ex);
throw;
}
}
private static IRestCollection AsCollection([NotNull] this IRestResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (resource is IRestCollection collection)
{
return(collection);
}
throw new ArgumentException("Resource was not a collection.", nameof(resource));
}
public override async Task <IEnumerable <TResponse> > GetAllAsync <TResponse>(IRestResource <BitBucketClientContext> resource,
BitBucketClientContext context)
{
var results = new List <TResponse>(200);
var url = this.BuildUri(context, () => resource.GetPagingUrl(context));
var response = await this.GetAsync(url.Uri).ConfigureAwait(false);
var page = await response.DeserializeAsync <BitBucketPagingResponse <TResponse> >().ConfigureAwait(false);
results.AddRange(page.Values);
while (page.Next.HasValue())
{
response = await this.GetAsync(page.Next).ConfigureAwait(false);
page = await response.DeserializeAsync <BitBucketPagingResponse <TResponse> >().ConfigureAwait(false);
results.AddRange(page.Values);
}
return(results);
}
public SingletonStartResourceFactory(IRestResource singletonResource)
{
_singletonResource = singletonResource;
}
public abstract Task <IEnumerable <TResponse> > GetAllAsync <TResponse>(IRestResource <TContext> resource, TContext context);
public IRestEndpoint Next(INextPath fieldName)
{
IRestResource resource = Item.GetField(fieldName.GetCoded());
return(Context.Services.EndpointResolver.GetFromResource(Context, resource));
}
public RestActionExecutionContext(ILykkeServiceRestClientSettings clientSettings, IRestResource resource, HttpClient client)
{
ClientSettings = clientSettings;
Resource = resource;
Client = client;
}
public override async Task <TResponse> PostAsync <TRequest, TResponse>(TRequest instance, IRestResource <BitBucketClientContext> resource,
BitBucketClientContext context)
{
var url = this.BuildUri(context, () => resource.GetActionUrl(context));
var request = new HttpRequestMessage(HttpMethod.Post, url.Uri);
request.Serialize(instance);
var response = await this.SendAsync(request).ConfigureAwait(false);
return(await response.DeserializeAsync <TResponse>().ConfigureAwait(false));
}
public abstract Task <TResponse> PostAsync <TRequest, TResponse>(TRequest instance, IRestResource <TContext> resource,
TContext context);
public abstract Task <PagingResponse <TResponse> > GetPageAsync <TResponse>(IRestResource <TContext> resource, TContext context);
public abstract Task <TResponse> GetAsync <TResponse>(IRestResource <TContext> resource, TContext context);
