/// <summary>
/// Executes the requested query against the actual database.
/// </summary>
/// <param name="dbContextFactory">
/// Factory for <see cref="DbContext" /> against which the requested query will be executed.
/// </param>
/// <param name="request">
/// The <see cref="QueryDataRequest" /> object from the client containing the query.
/// </param>
/// <returns>
/// The result of the query execution.
/// </returns>
public QueryDataResult QueryData(Func <DbContext> dbContextFactory, QueryDataRequest request)
{
using (DbContext dbContext = dbContextFactory())
{
return(new QueryDataHelper(dbContext, request, this.customValueMappers).QueryData());
}
}
public virtual async Task <QueryDataResult> QueryDataAsync(QueryDataRequest request, DbContext dbContext, CancellationToken cancellationToken)
{
IWcfService channel = this.channelFactory.CreateChannel();
using ((IDisposable)channel)
{
return(await channel.ProcessQueryDataRequestAsync(request));
}
}
public virtual QueryDataResult QueryData(QueryDataRequest request, DbContext dbContext)
{
IWcfService channel = this.channelFactory.CreateChannel();
using ((IDisposable)channel)
{
return(channel.ProcessQueryDataRequest(request));
}
}
public override void TestPerformed()
{
QueryDataRequest ws = new QueryDataRequest();
ws.WebServiceType = GetWebServiceType();
ws.Login = GetLogin();
ws.Limit = 1;
ws.Offset = 8;
WebServiceConnection client = GetClient();
try {
WindowTabDataResponse response = client.SendRequest(ws);
if (response.Status == WebServiceResponseStatus.Error)
{
Console.WriteLine(response.ErrorMessage);
}
else if (response.Status == WebServiceResponseStatus.Unsuccessful)
{
Console.WriteLine("Unsuccessful");
}
else
{
Console.WriteLine("Total rows: " + response.NumRows);
Console.WriteLine();
for (int i = 0; i < response.DataSet.GetRowsCount(); i++)
{
Console.WriteLine("Row: " + (i + 1));
for (int j = 0; j < response.DataSet.GetRow(i).GetFieldsCount(); j++)
{
Field field = response.DataSet.GetRow(i).GetFields()[j];
Console.WriteLine("Column: " + field.Column + " = " + field.Value);
if (field.Column.Equals("BinaryData") && !string.IsNullOrEmpty(field.Value.ToString()))
{
File.WriteAllBytes("img/QueryImageTest_" + response.DataSet.GetRow(i).GetField("AD_Image_ID").Value.ToString() + ".png", field.GetByteValue());
}
}
Console.WriteLine();
}
}
} catch (Exception e) {
Console.WriteLine(e);
}
}
public override void TestPerformed()
{
QueryDataRequest ws = new QueryDataRequest();
ws.WebServiceType = GetWebServiceType();
ws.Login = GetLogin();
ws.Offset = 1;
ws.Limit = 2;
DataRow data = new DataRow();
data.AddField("Name", "%Store%");
ws.DataRow = data;
WebServiceConnection client = GetClient();
try {
WindowTabDataResponse response = client.SendRequest(ws);
if (response.Status == WebServiceResponseStatus.Error)
{
Console.WriteLine(response.ErrorMessage);
}
else
{
Console.WriteLine("Total rows: " + response.TotalRows);
Console.WriteLine("Num rows: " + response.NumRows);
Console.WriteLine("Start rows: " + response.StartRow);
Console.WriteLine();
for (int i = 0; i < response.DataSet.GetRowsCount(); i++)
{
Console.WriteLine("Row: " + (i + 1));
for (int j = 0; j < response.DataSet.GetRow(i).GetFieldsCount(); j++)
{
Field field = response.DataSet.GetRow(i).GetFields()[j];
Console.WriteLine("Column: " + field.Column + " = " + field.Value);
}
Console.WriteLine();
}
}
} catch (Exception e) {
Console.WriteLine(e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryDataHelper" /> class.
/// </summary>
/// <param name="dbContext"> <see cref="DbContext" /> against which the requested query will be executed. </param>
/// <param name="request"> The <see cref="QueryDataRequest" /> object from the client containing the query. </param>
/// <param name="customValueMappers"> Custom value mappers. </param>
public QueryDataHelper(
DbContext dbContext,
QueryDataRequest request,
IEnumerable <IInfoCarrierValueMapper> customValueMappers)
{
this.dbContext = dbContext;
this.valueMappers = customValueMappers.Concat(StandardValueMappers.Mappers);
this.dbContext.ChangeTracker.QueryTrackingBehavior = request.TrackingBehavior;
IAsyncQueryProvider provider = this.dbContext.GetService <IAsyncQueryProvider>();
// UGLY: this resembles Remote.Linq.Expressions.ExpressionExtensions.PrepareForExecution()
// but excludes PartialEval (otherwise simple queries like db.Set<X>().First() are executed
// prematurely)
this.linqExpression = request.Query
.ReplaceNonGenericQueryArgumentsByGenericArguments()
.ReplaceResourceDescriptorsByQueryable(
this.typeResolver,
provider: type => (IQueryable)Activator.CreateInstance(typeof(EntityQueryable <>).MakeGenericType(type), provider))
.ToLinqExpression(this.typeResolver);
// Replace NullConditionalExpressionStub MethodCallExpression with NullConditionalExpression
this.linqExpression = Utils.ReplaceNullConditional(this.linqExpression, false);
}
public override Task <QueryDataResponse> QueryData(QueryDataRequest request, ServerCallContext context)
{
return(base.QueryData(request, context));
}
public QueryDataResult ProcessQueryDataRequest(QueryDataRequest request) => this.infoCarrierServer.QueryData(this.CreateDbContext, request);
public QueryDataResult QueryData(QueryDataRequest request, DbContext dbContext)
{
return(this.client.Send(new QueryData(request)).Result);
}
=> this.QueryDataAsync(request, dbContext, default).Result; // Watchout: https://stackoverflow.com/a/35831540
public async Task <QueryDataResult> QueryDataAsync(QueryDataRequest request, DbContext dbContext, CancellationToken cancellationToken)
=> JsonConvert.DeserializeObject <QueryDataResult>(
await this.CallApiAsync("QueryData", request, cancellationToken),
JsonSerializerSettings);
public QueryDataResult QueryData(QueryDataRequest request, DbContext dbContext) => this.QueryDataAsync(request, dbContext, default).Result; // Watchout: https://stackoverflow.com/a/35831540
public override async Task <QueryDataResult> QueryDataAsync(QueryDataRequest request, DbContext dbContext, CancellationToken cancellationToken) => await Task.Run(() => this.QueryData(request, dbContext), cancellationToken);
/// <summary>
/// Asynchronously executes the requested query against the actual database.
/// </summary>
/// <param name="dbContextFactory">
/// Factory for <see cref="DbContext" /> against which the requested query will be executed.
/// </param>
/// <param name="request">
/// The <see cref="QueryDataRequest" /> object from the client containing the query.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
/// </param>
/// <returns>
/// A task that represents the asynchronous operation.
/// The task result contains the result of the query execution.
/// </returns>
public async Task <QueryDataResult> QueryDataAsync(Func <DbContext> dbContextFactory, QueryDataRequest request, CancellationToken cancellationToken = default)
{
using (DbContext dbContext = dbContextFactory())
{
return(await new QueryDataHelper(dbContext, request, this.customValueMappers).QueryDataAsync(cancellationToken));
}
}
public QueryDataResult QueryData(QueryDataRequest request, DbContext dbContext)
=> SimulateNetworkTransferJson(
this.infoCarrierServer.QueryData(
this.CreateDbContextWithParameters(dbContext),
SimulateNetworkTransferJson(request)));
public async Task <QueryDataResult> QueryDataAsync(QueryDataRequest request, DbContext dbContext, CancellationToken cancellationToken)
{
return((await this.client.SendAsync(new QueryData(request), cancellationToken)).Result);
}
public async Task <QueryDataResult> QueryDataAsync(QueryDataRequest request, DbContext dbContext, CancellationToken cancellationToken)
=> SimulateNetworkTransferJson(
await this.infoCarrierServer.QueryDataAsync(
this.CreateDbContextWithParameters(dbContext),
SimulateNetworkTransferJson(request),
cancellationToken));
public Task <QueryDataResult> PostQueryDataAsync([FromBody] QueryDataRequest request) => this.infoCarrierServer.QueryDataAsync(this.CreateDbContext, request);
public override async Task <QueryDataResponse> QueryData(QueryDataRequest request, ServerCallContext context)
{
QueryDataResponse response = new QueryDataResponse();
IConnection connection = null;
try
{
_log.LogDebug("got a request: {0}", request);
connection = _connections.Get(request.PluginContext.DataSourceInstanceSettings);
var uaQueries = request.Queries.Select(q => new OpcUAQuery(q));
var invalidQueries = GetInvalidQueries(uaQueries);//uaQueries.Where(a => a.nodePath != null).ToLookup(a => a.refId);
var queryGroups = uaQueries.Where(a => !invalidQueries.ContainsKey(a.refId)).ToLookup(o => o.readType);
var nsTable = connection.Session.NamespaceUris;
foreach (var queryGroup in queryGroups)
{
var queries = queryGroup.ToArray();
try
{
Result <DataResponse>[] responses = null;
switch (queryGroup.Key)
{
case "ReadNode":
responses = ReadNodes(connection.Session, queries, nsTable);
break;
case "Subscribe":
responses = SubscribeDataValues(connection.Session, connection.DataValueSubscription, queries, nsTable);
break;
case "ReadDataRaw":
responses = ReadHistoryRaw(connection.Session, queries, nsTable);
break;
case "ReadDataProcessed":
responses = ReadHistoryProcessed(connection.Session, queries, nsTable);
break;
case "ReadEvents":
responses = ReadEvents(connection.Session, connection.EventDataResponse, queries, nsTable);
break;
case "SubscribeEvents":
responses = SubscribeEvents(connection.Session, connection.EventSubscription, queries, nsTable);
break;
case "Resource":
responses = null;
break;
}
if (responses != null)
{
int i = 0;
foreach (var dataResponse in responses)
{
if (dataResponse.Success)
{
response.Responses[queries[i++].refId] = dataResponse.Value;
}
else
{
var dr = new DataResponse();
dr.Error = string.Format("{0} {1}", dataResponse.StatusCode.ToString(), dataResponse.Error);
_log.LogError(dr.Error);
response.Responses[queries[i++].refId] = dr;
}
}
}
}
catch (Exception e)
{
foreach (var q in queries)
{
var dr = new DataResponse();
dr.Error = e.ToString();
response.Responses[q.refId] = dr;
}
_log.LogError(e.ToString());
}
}
foreach (var invalidQuery in invalidQueries)
{
var refId = invalidQuery.Key;
var message = invalidQuery.Value;
var dr = new DataResponse();
dr.Error = message;
response.Responses[refId] = dr;
_log.LogError(message);
}
}
catch (Exception ex)
{
// Close out the client connection.
_log.LogError("Error: {0}", ex);
connection?.Close();
}
return(await Task.FromResult(response));
}
/// <summary>
/// Send request for query data web service
/// </summary>
/// <param name="request">Request to send</param>
/// <returns>Response model</returns>
public WindowTabDataResponse SendRequest(QueryDataRequest request)
{
return((WindowTabDataResponse)SendRequest((WebServiceRequest)request));
}
public Task <QueryDataResult> ProcessQueryDataRequestAsync(QueryDataRequest request) => this.infoCarrierServer.QueryDataAsync(this.CreateDbContext, request);
public QueryData(QueryDataRequest request)
{
this.ToData(request);
}
