internal ResponseShim(IRestResponse resp,
IRequestShim req,
string baseUrl,
Exception error)
{
this.Request = req;
if (resp != null)
{
this.Code = resp.StatusCode;
this.Message = resp.StatusDescription;
//this.Content = Convert.ToBase64String(resp.RawBytes);
this.Content = UTF8Encoding.UTF8.GetString(
resp.RawBytes, 0, resp.RawBytes.Length);
this.IsSuccess = resp.IsSuccess;
}
this.BaseUrl = baseUrl;
this.Error = error;
var restErr = error as RestServiceException;
if (restErr != null)
{
this.Code = restErr.Code;
this.Message = restErr.Message;
}
}
internal ResponseShim(IRestResponse resp,
IRequestShim req,
string baseUrl,
Exception error)
{
this.Request = req;
if (resp != null)
{
this.Code = resp.StatusCode;
this.Message = resp.StatusDescription;
//this.Content = Convert.ToBase64String(resp.RawBytes);
this.Content = UTF8Encoding.UTF8.GetString(
resp.RawBytes, 0, resp.RawBytes.Length);
this.IsSuccess = resp.IsSuccess;
}
this.BaseUrl = baseUrl;
this.Error = error;
var restErr = error as RestServiceException;
if (restErr != null)
{
this.Code = restErr.Code;
this.Message = restErr.Message;
}
}
public async Task<T> Post<T>(T d7Node,
CancellationToken cancelToken)
where T : D7NodeBase, new()
{
if (!IsLoggedIn)
throw Error.BadAct($"‹{this.GetType().Name}› is not logged in.");
if (_client == null) throw Error.NullRef("_client");
IRequestShim req = null;
try {
req = _auth.Req.POST(URL.Api_EntityNode);
d7Node.uid = this.CurrentUser.uid;
req.Body = d7Node;
}
catch (Exception ex) { LogError("req = _auth.Req.POST", ex); return null; }
//Trace_n("Creating new node on server...", "");
T d7n = default(T); string m;
try
{
//d7n = await _client.Send<T>(req, cancelToken, "",
// "Successfully created new «{0}»: [nid: {1}] “{2}”",
// x => x?.type, x => x?.nid, x => x?.title);
d7n = await _client.Send<T>(req, cancelToken);
}
catch (RestServiceException ex) { OnNodeAdd.Err(this, ex); }
catch (Exception ex) { OnUnhandled.Err(this, ex); }
if (d7n.IsValidNode(out m))
return d7n;
else
return Error_(d7n, "Invalid node.", m);
}
private async Task TryUnserialized <T>(IRequestShim req, CancellationToken cancelToken)
{
Warn_o("Parsing error.");
//var expctd = JsonConvert.SerializeObject(new T(), Formatting.Indented);
//Trace_n("Inspecting unserialized...", "expected format:" + L.f + expctd);
var resp = await((IClientShim)this).Send(req, cancelToken);
if (resp != null)
{
Trace_n("Inspecting unserialized...", "actual from server:" + L.f + resp.Content);
}
}
private RestClient CreateClient(IRequestShim req)
{
Throw.IfBlank(BaseUrl, nameof(BaseUrl));
try {
//return new RestClient(new Uri(this.BaseUrl));
return(new RestClient(this.BaseUrl)
{
CookieContainer = new System.Net.CookieContainer(),
Credentials = new NetworkCredential(req.UserName, req.Password),
Authenticator = new HttpBasicAuthenticator()
});
}
catch (Exception ex)
{
LogError("new RestClient", ex);
return(null);
}
}
public async Task <IResponseShim> Send(IRequestShim request,
CancellationToken cancelToken,
string taskIntro,
object successMessage,
params object[] successMsgArgs)
{
Beginning:
var client = CreateClient(request);
var req = request as RequestShim;
//Trace_i(taskIntro.IsBlank() ? " [{0}] {1} ...".f(req.Method.ToString().ToUpper(), req.Resource) : taskIntro);
RestServiceException err = null;
IRestResponse resp = null; try
{
resp = await client.Execute(req.UnShim(), cancelToken);
}
catch (HttpRequestException ex)
{
err = RestErr(ex, req);
LogError($"client.Execute {req.Method}", err);
if (LowRetryIntervalSeconds > -1)
{
await TaskEx.Delay(1000 *LowRetryIntervalSeconds);
goto Beginning;
}
throw err;
}
catch (Exception ex) { throw Unhandled(ex); }
finally { client.Dispose(); }
//if (resp != null)
// Trace_o((successMessage == null) ? "response: [{0}] {1}".f((int)resp.StatusCode, resp.StatusDescription.Quotify()) : successMessage.ToString().f(successMsgArgs));
RaiseResponseReceived(true);
return(new ResponseShim(resp, request, this.BaseUrl, err));
}
public async Task <T> Send <T>(IRequestShim request,
CancellationToken cancelToken,
string taskIntro,
string successMessage,
params Func <T, object>[] successMsgArgs
)
{
Beginning:
var client = CreateClient(request);
if (client == null)
{
return(default(T));
}
var req = request as RequestShim;
bool tryNoParse = false;
//Trace_i(taskIntro.IsBlank() ? " [{0}] {1} ...".f(req.Method.ToString().ToUpper(), req.Resource) : taskIntro);
IRestResponse <T> resp = null; try
{
resp = await client.Execute <T>(req.UnShim(), cancelToken);
}
catch (HttpRequestException ex)
{
var err = RestErr(ex, req);
if (err.Code == HttpStatusCode.ServiceUnavailable)
{
Warn_n("Server is currently unavailable.", BaseUrl.Slash(req.Resource));
}
else if (err.Code == HttpStatusCode.Forbidden)
{
Error_n($"{BaseUrl} as “{req.UserName}”", err.Message);
}
else
{
LogError($"client.Execute<T> {req.Method}", err);
}
if (LowRetryIntervalSeconds > -1)
{
await TaskEx.Delay(1000 *LowRetryIntervalSeconds);
goto Beginning;
}
//if (err is InvalidSslRestException)
// Warn_h("Server is using a self-signed certificate.",
// "Application must be set to allow SSL from the server.");
//throw err;
return(default(T));
}
catch (JsonSerializationException ex)
{ tryNoParse = ParseErr <T>(ex); }
catch (JsonReaderException ex)
{ tryNoParse = ParseErr <T>(ex); }
catch (Exception ex) { throw Unhandled(ex); }
finally { client.Dispose(); }
if (tryNoParse)
{
await TryUnserialized <T>(req, cancelToken);
}
if (resp == null)
{
return(Warn_(default(T), "resp == null", "Unexpected NULL response from Send<>"));
}
//var args = successMsgArgs.Select(x =>
// x.Invoke(resp.Data)).ToArray();
//var msg = successMessage.IsBlank()
// ? $"response ‹{typeof(T).Name}›"
// + $": [{(int)resp.StatusCode}]"
// + $" “{resp.StatusDescription}”"
// : successMessage.f(args);
//Trace_o(msg);
RaiseResponseReceived(true);
return(resp.Data);
}
