async public Task <TM> Add(TM model)
{
try
{
if (string.IsNullOrWhiteSpace(ResourceName))
{
throw new ArgumentNullException(nameof(ResourceName));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var request = new HttpBody <TM>(model);
var response = await RestService.Post(ResourceName, request);
return(response?.Content);
}
catch (HttpException ex)
{
if (ex.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
ex.CheckRule();
throw;
}
}
async Task <HttpBody <T> > GetApi <T>(string resourceOrUrl, object param)
where T : class
{
HttpBody <T> result;
try
{
// Builds the url
string url = param.ToQueryString(resourceOrUrl);
// Gets JSON and parse the result
StringBody response = await HttpService.Get(url);
T data = JsonConvert.DeserializeObject <T>(response.Content);
result = new HttpBody <T>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
async public Task <ModelType> Update(ModelType model)
{
try
{
if (string.IsNullOrWhiteSpace(ResourceName))
{
throw new ArgumentNullException("ResourceName");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
var url = $"{ResourceName}/{model.Id}";
var request = new HttpBody <ModelType>(model);
var response = await RestService.Put(url, request);
return(response?.Content);
}
catch (HttpException ex)
{
if (ex.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
ex.CheckRule();
throw;
}
}
async Task <HttpBody <ResponseType> > PutApi <ResponseType>(string url, object input)
where ResponseType : class
{
var result = new HttpBody <ResponseType>();
try
{
// Posta o JSON no servidor, e realiza parse do retorno
var json = JsonConvert.SerializeObject(input);
var response = await HttpService.Put(url, json);
var data = JsonConvert.DeserializeObject <ResponseType>(response.Content);
result = new HttpBody <ResponseType>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
async Task <HttpBody <TR> > PostApi <TR, TB>(string url, HttpBody <TB> body)
where TR : class
where TB : class
{
HttpBody <TR> result;
try
{
HttpBody <string> response;
if (body.IsForm)
{
// Post FORM and parse the result
var dic = body.ToFormDictionaty();
response = await HttpService.Post(url, dic);
}
else
{
string json = string.Empty;
// Post JSON and parse the result
if (body.Content != null)
{
if (body.GetType() == typeof(string))
{
json = body as string;
}
else
{
json = JsonConvert.SerializeObject(body.Content);
}
}
response = await HttpService.Post(url, json);
}
var data = JsonConvert.DeserializeObject <TR>(response.Content);
result = new HttpBody <TR>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
async Task <HttpBody <T> > DeleteApi <T>(string url)
where T : class
{
HttpBody <T> result;
try
{
var response = await HttpService.Delete(url);
var data = JsonConvert.DeserializeObject <T>(response.Content);
result = new HttpBody <T>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
async Task <HttpBody <TR> > PutApi <TR>(string url, object input)
where TR : class
{
HttpBody <TR> result;
try
{
var json = JsonConvert.SerializeObject(input);
var response = await HttpService.Put(url, json);
var data = JsonConvert.DeserializeObject <TR>(response.Content);
result = new HttpBody <TR>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
async Task <HttpBody <ResponseType> > DeleteApi <ResponseType>(string url)
where ResponseType : class
{
var result = new HttpBody <ResponseType>();
try
{
// Recupera o JSON no servidor, e realiza parse do retorno
var response = await HttpService.Delete(url);
var data = JsonConvert.DeserializeObject <ResponseType>(response.Content);
result = new HttpBody <ResponseType>(data, response);
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException(ex);
}
return(result);
}
/// <summary>
/// Performs POST calls to add a new resource.
/// </summary>
/// <typeparam name="TR">The result model type</typeparam>
/// <typeparam name="TB">The body type</typeparam>
/// <param name="resource">The relative endpoint Url</param>
/// <param name="body">The body data</param>
/// <returns>The requested response</returns>
async public virtual Task <HttpBody <TR> > Post <TR, TB>(string resource, HttpBody <TB> body)
where TR : class
where TB : class
{
return(await PostApi <TR, TB>(resource, body));
}
/// <summary>
/// Performs PUT calls to add an existing resource.
/// </summary>
/// <typeparam name="T">The body type</typeparam>
/// <param name="resource">The relative endpoint Url</param>
/// <param name="body">The body data</param>
/// <returns>The requested response</returns>
async public virtual Task <HttpBody <T> > Put <T>(string resource, HttpBody <T> body)
where T : class
{
return(await Put <T, T>(resource, body));
}
/// <summary>
/// Performs POST calls to add a new resource.
/// </summary>
/// <typeparam name="ResponseType">The result model type</typeparam>
/// <typeparam name="BodyType">The body type</typeparam>
/// <param name="resource">The relative endpoint Url</param>
/// <param name="body">The body data</param>
/// <returns>The requested response</returns>
async public virtual Task <HttpBody <ResponseType> > Post <ResponseType, BodyType>(string resource, HttpBody <BodyType> body)
where ResponseType : class
where BodyType : class
{
return(await PostApi <ResponseType, BodyType>(resource, body));
}
/// <summary>
/// Performs PUT calls to add an existing resource.
/// </summary>
/// <typeparam name="BodyType">The body type</typeparam>
/// <param name="resource">The relative endpoint Url</param>
/// <param name="body">The body data</param>
/// <returns>The requested response</returns>
async public virtual Task <HttpBody <ResponseType> > Put <ResponseType>(string resource, HttpBody <ResponseType> body)
where ResponseType : class
{
return(await Put <ResponseType, ResponseType>(resource, body));
}