public async Task <string> Login(Credentials credentials)
{
var data = new Dictionary <string, string> {
{ "UserName", credentials.userName },
{ "Password", credentials.password },
{ "CompanyDB", credentials.database }
};
var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
_logger.LogInformation($"Login: {credentials.userName}@{credentials.database}");
HttpResponseMessage response = await httpClient.PostAsync("Login", content);
string token = string.Empty;
if (!response.IsSuccessStatusCode)
{
string body = await response.Content.ReadAsStringAsync();
string message = string.Empty;
if (response.StatusCode == HttpStatusCode.BadRequest)
{
ServiceLayerError error = parseError(body);
message = $"Error Connecting to Service Layer: {error.code} {error.message}";
}
else
{
message = $"Error Connecting to Service Layer: {response.StatusCode} {response.ReasonPhrase}";
}
_logger.LogError(message);
}
else
{
var responseString = await response.Content.ReadAsStringAsync();
dynamic finalResult = JsonConvert.DeserializeObject(responseString);
if (finalResult != null)
{
_SessionId = finalResult.SessionId;
var responseCookies = cookies.GetCookies(_SLServer).Cast <Cookie>();
var ck = responseCookies.FirstOrDefault(m => m.Name == "ROUTEID");
_RouteId = ck.Value;
}
_logger.LogInformation("Login succeded");
token = toToken(_SessionId, _RouteId);
}
return(token);
}
private ServiceLayerError parseError(string error)
{
ServiceLayerError result = null;
using (System.IO.StringReader sreader = new System.IO.StringReader(error))
using (JsonTextReader jsonTextReader = new JsonTextReader(sreader))
{
JToken j = JToken.ReadFrom(jsonTextReader);
string response = j.SelectToken("error").ToString();
result = JsonConvert.DeserializeObject <ServiceLayerError>(response);
}
return(result);
}
public async Task <string> getQueryResult(string query, bool noRoute = false)
{
addSecurityCookies(noRoute);
_logger.LogInformation($"GET {_SLServer}{query}");
HttpResponseMessage response = await httpClient.GetAsync(query);
string responseString = string.Empty;
if (!response.IsSuccessStatusCode)
{
string body = await response.Content.ReadAsStringAsync();
string message = string.Empty;
if (response.StatusCode == HttpStatusCode.BadRequest)
{
ServiceLayerError error = parseError(body);
message = $"Error running query {_SLServer}{query}: {error.code} {error.message}";
}
else
{
message = $"Error running query {_SLServer}{query}: {response.StatusCode} {response.ReasonPhrase}";
}
_logger.LogError(message);
}
else
{
_logger.LogInformation($"Success: {_SLServer}{query}");
responseString = await response.Content.ReadAsStringAsync();
}
return(responseString);
}
async public Task <List <ServiceLayerResponse> > parseMultiPartResponse(HttpResponseMessage response)
{
List <ServiceLayerResponse> responseList = new List <ServiceLayerResponse>();
var qp = from p in response.Content.Headers.ContentType.Parameters
where p.Name == "boundary"
select p;
var parameter = qp.FirstOrDefault();
string boundary = parameter == null ? "" : parameter.Value;
using (Stream responseMessage = await response.Content.ReadAsStreamAsync())
using (StreamReader reader = new StreamReader(responseMessage))
{
int statusCode = 0;
bool beginData = false;
string statusMessage = string.Empty;
StringBuilder submessage = new StringBuilder(512);
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (line.StartsWith($"--{boundary}"))
{
if (submessage.Length > 0)
{
ServiceLayerResponse slResponse = new ServiceLayerResponse();
if (statusCode == (int)HttpStatusCode.BadRequest)
{
ServiceLayerError error = parseError(submessage.ToString());
slResponse.success = false;
slResponse.errorCode = error.code;
slResponse.errorMessage = error.message.value;
}
else if (statusCode >= 300)
{
slResponse.success = false;
slResponse.errorCode = statusCode.ToString();
slResponse.errorMessage = statusMessage;
}
else
{
slResponse.success = true;
slResponse.errorCode = "";
slResponse.errorMessage = "";
slResponse.data = submessage.ToString();
}
responseList.Add(slResponse);
submessage.Clear();
statusCode = 0;
statusMessage = string.Empty;
beginData = false;
}
}
else if (line.StartsWith("HTTP"))
{
string[] httpResponse = line.Split(' ');
statusCode = int.Parse(httpResponse[1]);
statusMessage = string.Join(' ', httpResponse, 2, httpResponse.Length - 2);
}
else if (statusCode != 0 && line == string.Empty)
{
beginData = true;
}
else if (beginData)
{
submessage.Append(line);
}
}
}
return(responseList);
}
public async Task <ServiceLayerResponse> Send(HttpMethod method, string query, HttpContent payload, bool noRoute = false, bool returnContent = false)
{
ServiceLayerResponse slResponse = new ServiceLayerResponse();
addSecurityCookies(noRoute);
HttpRequestMessage message = new HttpRequestMessage(method, query);
message.Content = payload;
if (!returnContent)
{
message.Headers.Add("Prefer", "return-no-content");
}
HttpResponseMessage response = new HttpResponseMessage();
DateTime inicio = DateTime.Now;
try
{
response = await httpClient.SendAsync(message);
}
catch (Exception e)
{
}
var fim = DateTime.Now - inicio;
if (response.StatusCode == HttpStatusCode.BadRequest)
{
string responseContent = await response.Content.ReadAsStringAsync();
ServiceLayerError error = parseError(responseContent);
slResponse.success = false;
slResponse.errorCode = error.code;
slResponse.errorMessage = error.message.value;
_logger.LogError($"{method.Method.ToUpper()} {query}: {error.code} {error.message.value}");
}
else if (!response.IsSuccessStatusCode)
{
slResponse.success = false;
slResponse.errorCode = response.StatusCode.ToString();
slResponse.errorMessage = response.ReasonPhrase;
_logger.LogError($"{method.Method.ToUpper()} {query}: {slResponse.errorCode} {slResponse.errorMessage}");
}
else
{
slResponse.success = true;
slResponse.errorCode = "";
slResponse.errorMessage = "";
_logger.LogInformation($"{method.Method.ToUpper()} {query}: Success");
if (payload is MultipartContent)
{
slResponse.internalResponses = await parseMultiPartResponse(response);
if (slResponse.internalResponses != null)
{
foreach (var r in slResponse.internalResponses)
{
if (!r.success)
{
_logger.LogError($"{method.Method.ToUpper()} {query}: {r.errorCode} {r.errorMessage}");
}
}
}
}
else
{
slResponse.data = await response.Content.ReadAsStringAsync();
}
}
return(slResponse);
}
