public bool Authenticate(string userid, string psw, Uri gatewayUri, string sapclient, bool od4)
{
string bae = userid + ":" + psw;
var byteArray = Encoding.ASCII.GetBytes(bae);
AuthenticationHeaderValue headerValue = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
MeisterExtensions me = MeisterExtensions.RemoveNullsAndEmptyArrays;
MeisterOptions mo = MeisterOptions.None;
if (od4)
{
mo = MeisterOptions.UseODataV4;
}
RuntimeOptions ro = RuntimeOptions.ExecuteSync;
AuthenticationModes am = AuthenticationModes.Basic;
resource = new Resource <dynamic, dynamic>(gatewayUri, headerValue, sapclient, me, mo, am, ro);
return(resource.Authenticate());
}
/// <summary>
/// Execute internal of OData v2 call
/// </summary>
/// <typeparam name="REQ"></typeparam>
/// <typeparam name="RES"></typeparam>
/// <param name="endpoint"></param>
/// <param name="req"></param>
/// <param name="parm"></param>
/// <param name="runtimeOption"></param>
/// <returns></returns>
private OD2Body <RES> ExecuteODataV2Internal <REQ, RES>(string endpoint, REQ req, Parameters parm, RuntimeOptions runtimeOption, MeisterOptions options)
{
CancellationTokenSource cancel = null;
try
{
RestRequest request = new RestRequest(Method.GET);
DoResourceAllocation(request, ExecuteMeister);
request.AddQueryParameter(EndPoint, InQuotes(endpoint));
request.AddQueryParameter(Parms, InQuotes(PerformExtensions <Parameters>(parm)));
if (options.HasFlag(MeisterOptions.CompressionsOutbound))
{
request.AddQueryParameter(Content, InQuotes(Zip(PerformExtensions <REQ>(req))));
}
else
{
request.AddQueryParameter(Content, InQuotes(PerformExtensions <REQ>(req)));
}
cancel = new CancellationTokenSource();
IRestResponse <OD2Body <RES> > response = null;
if (runtimeOption.HasFlag(RuntimeOptions.ExecuteAsync))
{
var task = Task.Run(async() =>
{
response = await Client.ExecuteAsync <OD2Body <RES> >(request, cancel.Token).ConfigureAwait(true);
BuildStatusData <RES, OD2Body <RES> >(response);
return(response.Data);
});
task.Wait(cancel.Token);
return(task.Result);
}
else
{
return(ExecuteSync <OD2Body <RES> >(request).Result);
}
}
finally
{
if (cancel != null)
{
cancel.Dispose();
}
}
}
/// <summary>
/// Execute calls under OData v2
/// </summary>
/// <typeparam name="REQ"></typeparam>
/// <typeparam name="RES"></typeparam>
/// <param name="endpoint"></param>
/// <param name="req"></param>
/// <param name="parm"></param>
/// <param name="runtimeOption"></param>
/// <returns></returns>
#pragma warning disable 1998
internal dynamic ExecuteODataV2 <REQ, RES>(string endpoint, REQ req, Parameters parm, RuntimeOptions runtimeOption, MeisterOptions options)
{
OD2Body <RES> od2 = ExecuteODataV2Internal <REQ, RES>(endpoint, req, parm, runtimeOption, options);
if (od2 == null)
{
return(null);
}
else if (od2.d == null && runtimeOption == RuntimeOptions.ExecuteSync)
{
throw new MeisterException(resourceManager.GetString("OData2Failure", CultureInfo.InvariantCulture));
}
else
{
try
{
string json = string.Empty;
var list = od2.d.results;
if (list != null && list.Count > 0)
{
if (options.HasFlag(MeisterOptions.CompressionsOutbound))
{
json = Unzip(list.FirstOrDefault().Json);
}
else
{
json = list.FirstOrDefault().Json;
}
json = RemoveDrefAnnotations(json);
}
// first check if the backend sent a canonical failure .. if not, do nothing at the exception ..
// it comes in two flavors, as an object when threw from the gateway directly or as a list when threw from the backend
try
{
BackendFailure failure = JsonConvert.DeserializeObject <BackendFailure>(json);
if (failure != null)
{
throw new MeisterException(failure.BackendMessage, HttpStatusCode.InternalServerError);
}
}
catch (Exception)
{
try
{
List <BackendFailure> failures = JsonConvert.DeserializeObject <List <BackendFailure> >(json);
if (failures != null && failures.Count > 0)
{
BackendFailure failure = failures.FirstOrDefault();
if (failure.ReturnCode > 0)
{
throw new MeisterException(failure.BackendMessage, HttpStatusCode.InternalServerError);
}
}
}
catch (Exception)
{
}
}
return(VanillaProcess <RES>(json));
}
catch (MeisterException mex)
{
MeisterStatus.StatusCode = mex.httpStatusCode;
MeisterStatus.LogEntry = mex.Message;
throw;
}
catch (Exception ex)
{
MeisterStatus.StatusCode = System.Net.HttpStatusCode.NotImplemented;
MeisterStatus.LogEntry = ex.Message;
throw new MeisterException(resourceManager.GetString("UnableToMashallOD2", CultureInfo.InvariantCulture));
}
}
}
/// <summary>
/// Internal runtime for OD4
/// </summary>
/// <typeparam name="REQ"></typeparam>
/// <typeparam name="RES"></typeparam>
/// <param name="endpoint"></param>
/// <param name="req"></param>
/// <param name="parm"></param>
/// <param name="runtimeOption"></param>
/// <returns></returns>
private OD4Body <RES> ExecuteODataV4Internal <REQ, RES>(string endpoint, REQ req, Parameters parm, RuntimeOptions runtimeOption, MeisterOptions options)
{
CancellationTokenSource cancel = null;
try
{
RestRequest request = null;
if (string.IsNullOrEmpty(CsrfToken))
{
request = new RestRequest(Method.GET);
DoResourceAllocation(request, TokenFetch);
request.AddHeader(csrf, "Fetch");
Client.CookieContainer = new CookieContainer();
IRestResponse resp = Client.Execute(request);
if (HttpResponseInValidRange(resp.StatusCode))
{
CsrfToken = (from h in resp.Headers where h.Name == csrf select h).FirstOrDefault().Value.ToString();
request = null;
}
else
{
throw new MeisterException(resourceManager.GetString("FailedCsrfToken", CultureInfo.InvariantCulture));
}
}
IRestResponse <OD4Body <RES> > response = null;
request = new RestRequest(Method.POST);
request.RequestFormat = DataFormat.Json;
var body = new Body <REQ>(endpoint, parm, req);
var bodycall = new BodyCall();
DoResourceAllocation(request, ExecuteMeister);
bodycall.Parms = PerformExtensions <Parameters>(body.Parms);
bodycall.Endpoint = body.Endpoint;
bodycall.Json = PerformExtensions <REQ>(body.Json);
if (options.HasFlag(MeisterOptions.CompressionsInbound))
{
bodycall.Json = Zip(bodycall.Json);
}
string json = JsonConvert.SerializeObject(bodycall);
cancel = new CancellationTokenSource();
request.AddJsonBody(json);
request.AddHeader("X-Request-With", "XMLHttpRequest");
request.AddHeader("Accept", "*/*");
request.AddHeader(csrf, CsrfToken);
request.AddHeader("Content-Type", "application/json;odata.metadata=minimal; charset=utf-8");
response = null;
if (runtimeOption.HasFlag(RuntimeOptions.ExecuteAsync))
{
var task = Task.Run(async() =>
{
response = await Client.ExecuteAsync <OD4Body <RES> >(request, cancel.Token).ConfigureAwait(true);
BuildStatusData <RES, OD4Body <RES> >(response);
return(response.Data);
});
task.Wait(cancel.Token);
return(task.Result);
}
else
{
return(ExecuteSync <OD4Body <RES> >(request).Result);
}
}
finally
{
if (cancel != null)
{
cancel.Dispose();
}
}
}
/// <summary>
/// Execute under OData v4
/// </summary>
/// <typeparam name="REQ"></typeparam>
/// <typeparam name="RES"></typeparam>
/// <param name="endpoint"></param>
/// <param name="req"></param>
/// <param name="parm"></param>
/// <param name="runtimeOption"></param>
/// <returns></returns>
internal dynamic ExecuteODataV4 <REQ, RES>(string endpoint, REQ req, Parameters parm, RuntimeOptions runtimeOption, MeisterOptions options)
{
OD4Body <RES> od4 = ExecuteODataV4Internal <REQ, RES>(endpoint, req, parm, runtimeOption, options);
if (od4 == null)
{
return(null);
}
else if (string.IsNullOrEmpty(od4.odatacontext) && runtimeOption == RuntimeOptions.ExecuteSync)
{
throw new MeisterException(od4.value);
}
else if (string.IsNullOrEmpty(od4.odatacontext) && string.IsNullOrEmpty(od4.value))
{
throw new MeisterException(od4.value);
}
else
{
try
{
string json = string.Empty;
if (options.HasFlag(MeisterOptions.CompressionsOutbound))
{
json = Unzip(od4.value);
}
else
{
json = od4.value;
}
json = RemoveDrefAnnotations(json);
return(VanillaProcess <RES>(json));
}
catch (MeisterException)
{
throw new MeisterException(resourceManager.GetString("UnableToMarshall", CultureInfo.InvariantCulture) + od4.value);
}
}
}
/// <summary>
/// Meister execution path
/// </summary>
/// <typeparam name="REQ"></typeparam>
/// <typeparam name="RES"></typeparam>
/// <param name="endpoint"></param>
/// <param name="req"></param>
/// <param name="parm"></param>
/// <param name="runtimeOption"></param>
/// <param name="options"></param>
/// <returns></returns>
internal dynamic Execute <REQ, RES>(string endpoint, REQ req, Parameters Parm, RuntimeOptions RuntimeOption, MeisterOptions options)
{
if (options.HasFlag(MeisterOptions.UseODataV4))
{
return(ExecuteODataV4 <REQ, RES>(endpoint, req, Parm, RuntimeOption, options));
}
else
{
return(ExecuteODataV2 <REQ, RES>(endpoint, req, Parm, RuntimeOption, options));
}
}
/// <summary>
/// Full ctor
/// </summary>
/// <param name="uri"></param>
/// <param name="cretendials"></param>
/// <param name="extensions"></param>
/// <param name="options"></param>
/// <param name="authentication"></param>
/// <param name="runtimeOptions"></param>
public Resource(Uri uri, AuthenticationHeaderValue cretendials, string sapClient = null, MeisterExtensions extensions = MeisterExtensions.RemoveNullsAndEmptyArrays, MeisterOptions options = MeisterOptions.None, AuthenticationModes authentication = AuthenticationModes.Basic, RuntimeOptions runtimeOptions = RuntimeOptions.ExecuteAsync, Languages language = Languages.CultureBased) : base()
{
resource = new Resource <dynamic, dynamic>(uri, cretendials, sapClient, extensions, options, authentication, runtimeOptions, language);
}
