/// <summary>
/// Saves a file.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ApiResponse <CreatedWithIdResponse <int> > > SaveFileAsync(SaveFileRequest request)
{
Arg.IsNotNull(request, nameof(request));
var streamContent = new StreamContent(request.FileStream);
streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(request.ContentType);
var path = UrlHelper.GetSaveFilePath();
var multiPartContent = new MultipartFormDataContent
{
{ streamContent, "file", request.FileName },
{ new StringContent(request.RecordId.ToString()), nameof(request.RecordId) },
{ new StringContent(request.FieldId.ToString()), nameof(request.FieldId) },
{ new StringContent(request.Notes), nameof(request.Notes) },
};
if (request.ModifiedDate != null)
{
multiPartContent.Add(new StringContent(request.ModifiedDate.ToString()), nameof(request.ModifiedDate));
}
var httpRequest = new HttpRequestMessage(HttpMethod.Post, path)
{
Content = multiPartContent,
};
var httpResponse = await HttpClient.SendAsync(httpRequest);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync <CreatedWithIdResponse <int> >(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
public ApiResponse Get(string name)
{
ResponseModel <List <CustomerDTO> > result;
result = _customerservice.Search(name);
return(ApiResponseFactory <List <CustomerDTO> > .GetResponse(result));
}
/// <summary>
/// Gets a file.
/// </summary>
/// <param name="recordId"></param>
/// <param name="fieldId"></param>
/// <param name="fileId"></param>
/// <returns></returns>
public async Task <ApiResponse <GetFileResponse> > GetFileAsync(int recordId, int fieldId, int fileId)
{
var path = UrlHelper.GetFilePath(recordId, fieldId, fileId);
var response = await HttpClient.GetAsync(path, ClientConfig.ApiKey);
var message = await ApiResponseFactory.TryGetMessageAsync(response, ClientConfig.JsonSerializer);
var apiResponse = new ApiResponse <GetFileResponse>
{
Message = message,
StatusCode = response.StatusCode,
};
if (response.IsSuccessStatusCode)
{
var fileStream = await response.Content.ReadAsStreamAsync();
apiResponse.Value = new GetFileResponse()
{
FileName = response.Content.Headers?.ContentDisposition?.FileName,
ContentLength = response.Content.Headers?.ContentLength ?? 0,
ContentType = response.Content.Headers?.ContentType?.MediaType,
Stream = fileStream,
};
}
return(apiResponse);
}
public AuthController(UserManager <UserAccount> userManager, RoleManager <IdentityRole> roleManager,
IConfiguration configuration, ApiResponseFactory responseFactory)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.configuration = configuration;
this.responseFactory = responseFactory;
}
internal ServicesBase(string apiKey, string apiBaseUrl, int metarTafCacheTimeInMinutes, int stationCacheTimeInMinutes, string acceptHeader)
{
Http = new Http(apiKey, apiBaseUrl, metarTafCacheTimeInMinutes, stationCacheTimeInMinutes, acceptHeader);
ApiHandles = new ApiHandles();
RawStreakApiResponseFactory = new ApiResponseFactory();
MetarTafCacheTimeInMinutes = metarTafCacheTimeInMinutes;
StationCacheTimeInMinutes = stationCacheTimeInMinutes;
}
/// <summary>
/// Performs an HTTP POST request to the <paramref name="path"/> and adds an API Key header.
/// </summary>
/// <param name="path"></param>
/// <param name="content"></param>
/// <returns></returns>
private async Task <ApiResponse> PostAsync(string path, object content)
{
var httpResponse = await HttpClient.PostAsync(path, ClientConfig.ApiKey, content);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
// ------------------------------------ Client internals ------------------------------------
/// <summary>
/// Performs an HTTP DELETE request to the <paramref name="path"/> and adds an API Key header.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private async Task <ApiResponse> DeleteAsync(string path)
{
var httpResponse = await HttpClient.DeleteAsync(path, ClientConfig.ApiKey);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
public async Task <ApiResponse> Update([FromBody] CustomerDTO customerDTO)
{
ResponseModel <CustomerDTO> result;
result = await _customerservice.Update(customerDTO);
return(ApiResponseFactory <CustomerDTO> .GetResponse(result));
}
public async Task <ApiResponse> Delete(int id)
{
ResponseModel <bool> result;
result = await _customerservice.Delete(id);
return(ApiResponseFactory <bool> .GetResponse(result));
}
/// <summary>
/// Performs an HTTP PUT request to the <paramref name="path"/> and adds an API Key header.
/// </summary>
/// <typeparam name="TOutput"></typeparam>
/// <param name="path"></param>
/// <param name="content"></param>
/// <returns></returns>
private async Task <ApiResponse <TOutput> > PutAsync <TOutput>(string path, object content)
where TOutput : class
{
var httpResponse = await HttpClient.PutAsync(path, ClientConfig.ApiKey, content);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync <TOutput>(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
/// <summary>
/// Performs an HTTP GET request to the <paramref name="path"/> and adds an API Key header.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <returns></returns>
private async Task <ApiResponse <T> > GetAsync <T>(string path)
where T : class
{
var httpResponse = await HttpClient.GetAsync(path, ClientConfig.ApiKey);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync <T>(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
public SubscriptionController(UserManager <UserAccount> userManager,
SubscriptionManager subscriptionManager,
ApiResponseFactory responseFactory,
ApiModelFactory modelFactory,
IOptionManager optionManager)
{
this.userManager = userManager;
this.subscriptionManager = subscriptionManager;
this.responseFactory = responseFactory;
this.modelFactory = modelFactory;
this.optionManager = optionManager;
}
public async Task <ApiResponse> PostOrder([FromBody] CustomerOrderDTO customerOrderDTO)
{
ResponseModel <CustomerOrderDTO> result;
if (!ModelState.IsValid)
{
throw new ApiException(ModelState.AllErrors());
}
result = await _orderservice.Create(customerOrderDTO);
return(ApiResponseFactory <CustomerOrderDTO> .GetResponse(result));
}
public VideoController(UserManager <UserAccount> userManager,
VideoManager videoManager,
SubscriptionManager subscriptionManager,
ApiResponseFactory responseFactory,
ApiModelFactory modelFactory,
IVideoStorageService videoStorage)
{
this.userManager = userManager;
this.videoManager = videoManager;
this.subscriptionManager = subscriptionManager;
this.responseFactory = responseFactory;
this.modelFactory = modelFactory;
this.videoStorage = videoStorage;
}
public ActionResult GetLocalFiles()
{
var localFilePaths = _fileService.GetLocalFiles();
return(Ok(ApiResponseFactory.CreateSuccess(localFilePaths)));
}
public async Task <ActionResult> GetEpisodeById(int episodeId)
{
var res = await _episodeProvider.GetByIdAsync(new GetByIdRequest { Id = episodeId });
return(Ok(ApiResponseFactory.CreateSuccess(res.Episode)));
}
public SetupController(UserManager <UserAccount> userManager, IOptionManager optionManager, ApiResponseFactory responseFactory)
{
this.userManager = userManager;
this.optionManager = optionManager;
this.responseFactory = responseFactory;
}
public ActionResult SaveSettings([FromBody] App.Settings.ProtoGenerated.Settings settings)
{
_settingsService.Save(settings);
return(Ok(ApiResponseFactory.CreateSuccess(new { })));
}
public ActionResult GetSettings()
{
var settings = _settingsService.Get();
return(Ok(ApiResponseFactory.CreateSuccess(settings)));
}
public async Task <ActionResult> GetSeriesById(int id)
{
var res = await _seriesProvider.GetByIdAsync(new GetByIdRequest { Id = id });
return(Ok(ApiResponseFactory.CreateSuccess(res.Series)));
}
public async Task <ActionResult> GetSeries()
{
var res = await _seriesProvider.GetAllAsync(new GetAllRequest());
return(Ok(ApiResponseFactory.CreateSuccess(res.Series)));
}
public async Task <ActionResult> IsOnline()
{
var isOnline = await _statusService.IsOnline();
return(Ok(ApiResponseFactory.CreateSuccess(isOnline)));
}
