public ListResponse<MedicineDto> GetMatchingMedicines(QueryRequest<MedicineQuery> request)
{
try
{
using (var dbContext = new AptekaNETDbContext())
{
var medicines = dbContext.Medicines.AsEnumerable().Where(p => request.Query.IsMatch(p)).ToList();
if (medicines.Any())
{
var medicineDtos = medicines.Select(p => _medicineAssembler.ToDto(p)).ToList();
return new ListResponse<MedicineDto>(request.Id, medicineDtos)
{
Message = "Pobrano pomyślnie"
};
}
return new ListResponse<MedicineDto>(request.Id, new List<MedicineDto>())
{
Message = "Nie ma leku spełniającego powyższe warunki"
};
}
}
catch (Exception e)
{
return new ListResponse<MedicineDto>(request.Id, new List<MedicineDto>())
{
Message = "Błąd"
};
}
}
public QueryRequest GetMetadataByNameQueryRequest(string name, Guid pageTypeId, Guid languageId, SecurityToken token)
{
// Set up page query.
var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token);
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId));
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.Name, name) { AllowFuzzy = false });
// Only published pages.
request.FilterTags.Add(new Tag(TagNames.IsPublished, true));
request.Paging = Paging.Default;
return request;
}
/// <summary>
/// Gets a list of metadatas with only the most basic information set (ID and Name).
/// </summary>
/// <param name="request">The request.</param>
/// <param name="searchService">The search service.</param>
/// <param name="siteMapCache">The site map cache.</param>
/// <returns>A list of metadata with most basic information</returns>
public List<Metadata> GetBasicMetadata(QueryRequest request, SiteMapCache siteMapCache)
{
SearchResponse response = Solution.Instance.SearchService.Search(request);
List<Metadata> metadatas = new List<Metadata>();
if (response != null)
{
List<PageInfoCarrier> pages = GetPageInfoCarriersFromSearchResponse(response, siteMapCache);
foreach (PageInfoCarrier page in pages)
{
metadatas.Add(new Metadata(page, this));
}
}
else
{
_log.Error("Search returned null instead of zero results.");
}
return metadatas;
}
/// <summary>
/// Overridden. Starts to create the requested object,
/// either immediately or on a background thread,
/// based on the value of the IsAsynchronous property.
/// </summary>
protected override void BeginQuery()
{
if (this._init) return;
if (this._firstRun)
{
this._firstRun = false;
if (!IsInitialLoadEnabled) return;
}
if (this._endInitError)
{
// this handles a case where the WPF form initilizer
// invokes the data provider twice when an exception
// occurs - we really don't want to try the query twice
// or report the error twice
this._endInitError = false;
this.OnQueryFinished(null, null, null, null);
return;
}
if (this.IsRefreshDeferred) return;
var request = new QueryRequest()
{
DataProducer = this.DataProducer,
Version = this._queryVersion
};
this.IsBusy = true;
AsyncHelper.Invoke(() => DoQuery(request));
}
private RequestBase SearchInternal(QuerySetup setup)
{
_searchType = setup.SearchType;
setup.SearchText.EnsureNotNull("searchText");
if (setup.From > 10000 || setup.Size > 10000)
{
throw new ArgumentOutOfRangeException(nameof(setup),
"From (skip) and size (take) must be less than or equal to: 10000. If you really must, this limit can be set by changing the [index.max_result_window] index level parameter");
}
var request = new QueryRequest(setup);
request.Query.SearchText = setup.SearchText.ToLower();
if (setup.SearchFields.Count == 0)
{
setup.SearchFields.AddRange(GetMappedFields(Language.GetLanguageCode(setup.Language), setup.IndexName, setup.SearchType));
}
if (Log.IsDebugEnabled())
{
Log.Debug("SearchFields:");
setup.SearchFields.ForEach(f => Log.Debug(f));
}
SetupAttachmentFields(setup);
SetupSourceFields(request, setup);
if (setup.IsGetQuery)
{
request.Query.Bool.Must.Add(new MatchAll());
}
else if (setup.IsWildcard)
{
setup.SearchFields.ForEach(field =>
request.Query.Bool.Should.Add(new Wildcard(field, request.Query.SearchText)));
// Boost hits that starts with searchtext, ie. when searching for "*foo*",
// hits on "foobar" will score higher than hits on "barfoo"
if (request.Query.SearchText.StartsWith("*"))
{
setup.SearchFields.ForEach(field =>
request.Query.Bool.Should.Add(new Wildcard(field, request.Query.SearchText.TrimStart('*'), 10)));
}
request.Query.Bool.MinimumNumberShouldMatch = 1;
}
else
{
request.Query.Bool.Must.Add(
new MatchMulti(
request.Query.SearchText,
setup.SearchFields,
setup.Operator,
null,
null,
setup.FuzzyLength,
setup.Analyzer));
// Boost phrase matches if multiple words
if (request.Query.SearchText?.IndexOf(" ", StringComparison.OrdinalIgnoreCase) > 0)
{
request.Query.Bool.Should.Add(
new MatchMulti(
request.Query.SearchText,
setup.SearchFields,
setup.Operator,
"phrase",
2));
}
}
SetupBoosting(setup, request);
if (setup.FacetFieldNames.Count > 0)
{
request.Aggregation = GetAggregationQuery(setup.FacetFieldNames);
}
SetupFilters(setup, request);
// Highlighting
if (setup.UseHighlight)
{
request.Highlight = new Highlight
{
Fields = GetHighlightFields()
};
}
// Did-you-mean
if (setup.EnableDidYouMean)
{
request.DidYouMeanSuggest = new DidYouMeanSuggest(request.Query.SearchText);
}
// function_score. Must be the last operation in this method.
// Cannot use Gauss and ScriptScore simultaneously
if (setup.ScriptScore != null && setup.Gauss.Count > 0)
{
throw new Exception("Cannot use Gauss and ScriptScore simultaneously");
}
if (setup.ScriptScore != null)
{
request.Query = new FunctionScoreQuery(request.Query, setup.ScriptScore);
}
if (setup.Gauss.Count > 0)
{
request.Query = new FunctionScoreQuery(request.Query, setup.Gauss);
}
return(request);
}
/// <summary>
/// Queries the resources managed by Azure Resource Manager for scopes
/// specified in the request.
/// <see href="https://aka.ms/resource-graph/learntoquery" />
/// </summary>
/// <param name='query'>
/// Request specifying query and its options.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <QueryResponse> > ResourcesWithHttpMessagesAsync(QueryRequest query, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.ApiVersion");
}
if (query == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "query");
}
if (query != null)
{
query.Validate();
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("query", query);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "Resources", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "providers/Microsoft.ResourceGraph/resources").ToString();
List <string> _queryParameters = new List <string>();
if (ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (GenerateClientRequestId != null && GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (query != null)
{
_requestContent = SafeJsonConvert.SerializeObject(query, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <QueryResponse>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <QueryResponse>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Gets executed once the idle timeout has passed
/// </summary>
private void IdleTimeoutHandler(object state)
{
//Ensure there are no more idle timeouts until the query finished sending
if (_isCanceled)
{
if (!IsDisposed)
{
//If it was not manually disposed
_logger.Warning("Can not issue an heartbeat request as connection is closed");
if (OnIdleRequestException != null)
{
OnIdleRequestException(new SocketException((int)SocketError.NotConnected));
}
}
return;
}
_logger.Verbose("Connection idling, issuing a Request to prevent idle disconnects");
var request = new QueryRequest(ProtocolVersion, IdleQuery, false, QueryProtocolOptions.Default);
Send(request, (ex, response) =>
{
if (ex == null)
{
//The send succeeded
//There is a valid response but we don't care about the response
return;
}
_logger.Warning("Received heartbeat request exception " + ex.ToString());
if (ex is SocketException && OnIdleRequestException != null)
{
OnIdleRequestException(ex);
}
});
}
public override Task <QueryResponse> query(QueryRequest request, ServerCallContext context)
{
return(Task.FromResult(new QueryResponse {
SqlData = Program.QueryCommand()
}));
}
/// <summary>
/// Executes Time Series Query in pages of results - Get Events, Get Series or
/// Aggregate Series.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='parameters'>
/// Time series query request body.
/// </param>
/// <param name='storeType'>
/// For the environments with warm store enabled, the query can be executed
/// either on the 'WarmStore' or 'ColdStore'. This parameter in the query
/// defines which store the query should be executed on. If not defined, the
/// query will be executed on the cold store.
/// </param>
/// <param name='continuationToken'>
/// Continuation token from previous page of results to retrieve the next page
/// of the results in calls that support pagination. To get the first page
/// results, specify null continuation token as parameter value. Returned
/// continuation token is null if all results have been returned, and there is
/// no next page of results.
/// </param>
/// <param name='clientRequestId'>
/// Optional client request ID. Service records this value. Allows the service
/// to trace operation across services, and allows the customer to contact
/// support regarding a particular request.
/// </param>
/// <param name='clientSessionId'>
/// Optional client session ID. Service records this value. Allows the service
/// to trace a group of related operations across services, and allows the
/// customer to contact support regarding a particular group of requests.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <QueryResultPage> ExecuteAsync(this IQuery operations, QueryRequest parameters, string storeType = default(string), string continuationToken = default(string), string clientRequestId = default(string), string clientSessionId = default(string), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ExecuteWithHttpMessagesAsync(parameters, storeType, continuationToken, clientRequestId, clientSessionId, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(Guid metadataId, Guid parentPageId, Guid webSiteId, Guid languageId, int pageIndex, int pageSize, SecurityToken token)
{
var request = new QueryRequest(languageId, SearchDomains.Pages, token);
// Make sure page is searchable
request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString));
// Make sure pages are published
request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString));
if (parentPageId != Guid.Empty)
{
// Only search pages under specified page
request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId));
}
if (webSiteId != Guid.Empty)
{
// Only search pages under specified web site
request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId));
}
// Add required metadatas as filter
request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadataId));
// Set paging
request.Paging = GetPaging(pageIndex, pageSize);
return request;
}
public virtual Task <IEnumerable <DeviceGroup> > GetDeviceGroups(QueryRequest request, CancellationToken cancellationToken)
{
return(DataSource?.GetDeviceGroups(request, cancellationToken) ?? Task.FromResult(new List <DeviceGroup>().AsEnumerable()));
}
public override void Query(IRpcController controller, QueryRequest request, Action<QueryResponse> done)
{
throw new NotImplementedException();
}
public Task<IEnumerable<Row>> QueryAsync(string cqlQuery, bool retry = false)
{
var request = new QueryRequest(ProtocolVersion, cqlQuery, false, QueryProtocolOptions.Default);
var task = _connection
.Send(request)
.ContinueSync(GetRowSet);
if (!retry)
{
return task;
}
return task.ContinueWith(t =>
{
var ex = t.Exception != null ? t.Exception.InnerException : null;
if (ex is SocketException)
{
const string message = "There was an error while executing on the host {0} the query '{1}'";
_logger.Error(string.Format(message, cqlQuery, _connection.Address), ex);
//Reconnect and query again
return Reconnect()
.Then(_ => QueryAsync(cqlQuery, false));
}
return task;
}).Unwrap();
}
public QueryResponse Query(QueryRequest request)
{
return client.Query(request);
}
private void Exception_Query(QueryRequest req, Exception ex)
{
_queryResults = new QueryResults(req.ConnectionString, req.SQLStatement, ex.Message);
DoSOM();
}
private void Finished_Query(QueryRequest req, QueryResults results)
{
_queryResults = results;
DoSOM();
}
private static void SetupFilters(QuerySetup setup, QueryRequest request)
{
var filterQuery = new NestedBoolQuery();
// Filter away excluded types
if (setup.ExcludedTypes.Count > 0)
{
filterQuery.Bool.MustNot.AddRange(setup.ExcludedTypes.Select(e => new MatchSimple(DefaultFields.Types, e.GetTypeName().ToLower())));
}
foreach (var ex in GetExcludedRoots(setup))
{
filterQuery.Bool.MustNot.Add(new MatchSimple(DefaultFields.Id, ex.Key.ToString()));
if (ex.Value)
{
filterQuery.Bool.MustNot.Add(new MatchSimple(DefaultFields.Path, ex.Key.ToString()));
}
}
// Filter on type
if (setup.Type != null)
{
var term = CreateTerm(new Filter(DefaultFields.Types, setup.Type.GetTypeName().ToLower(), null, false, Operator.And));
filterQuery.Bool.Must.Add(term);
}
// Filter on ranges
if (setup.Ranges.Count > 0)
{
request.Query.Bool.Filter.AddRange(setup.Ranges);
}
// Filter on root-id
if (setup.RootId != 0)
{
var term = new Term(DefaultFields.Path, Convert.ToString(setup.RootId), true);
filterQuery.Bool.Must.Add(term);
}
// Filter on ACL
if (setup.AppendAclFilters && setup.AclPrincipal != null)
{
var boolQuery = new NestedBoolQuery();
foreach (var role in setup.AclPrincipal.RoleList)
{
var roleTerm = new MatchSimple(DefaultFields.Acl, $"R:{role}");
boolQuery.Bool.Should.Add(roleTerm);
}
var userTerm = new MatchSimple(DefaultFields.Acl, $"U:{setup.AclPrincipal.Name}");
boolQuery.Bool.Should.Add(userTerm);
boolQuery.Bool.MinimumNumberShouldMatch = 1;
request.Query.Bool.Filter.Add(boolQuery);
}
if (setup.FilterGroups.Count > 0)
{
foreach (var filterGroup in setup.FilterGroups)
{
foreach (var filter in filterGroup.Value.Filters)
{
var boolQuery = new BoolQuery();
if (filter.Operator == Operator.Or)
{
boolQuery.MinimumNumberShouldMatch = 1;
boolQuery.Should = new List <MatchBase>();
if (ArrayHelper.IsArrayCandidate(filter.Value.GetType()))
{
foreach (object value in (IEnumerable)ArrayHelper.ToArray(filter.Value))
{
boolQuery.Should.Add(Term.FromFilter(filter, value));
}
}
else
{
boolQuery.Should.Add(Term.FromFilter(filter));
}
}
else if (filter.Operator == Operator.And)
{
boolQuery.Must = new List <MatchBase>();
if (ArrayHelper.IsArrayCandidate(filter.Value.GetType()))
{
foreach (object value in (IEnumerable)ArrayHelper.ToArray(filter.Value))
{
boolQuery.Must.Add(Term.FromFilter(filter, value));
}
}
else
{
boolQuery.Must.Add(Term.FromFilter(filter));
}
}
// Use regular or post filter?
if (!setup.UsePostfilters)
{
request.Query.Bool.Filter.Add(Term.FromArrayFilter(filter));
}
else
{
if (filterGroup.Value.Operator == Operator.And)
{
request.PostFilter.Bool.Must.Add(new NestedBoolQuery(boolQuery));
}
else if (filterGroup.Value.Operator == Operator.Or)
{
request.PostFilter.Bool.Should.Add(new NestedBoolQuery(boolQuery));
}
}
}
}
}
if (setup.Filters.Count > 0)
{
// Add not-filters as regular filter regardless of post-filter value
IEnumerable <Filter> notFilters = setup.Filters.Where(f => f.Not).ToArray();
filterQuery.Bool.MustNot.AddRange(notFilters.Select(CreateTerm));
// Use regular or post filter?
if (!setup.UsePostfilters)
{
request.Query.Bool.Filter.AddRange(
setup.Filters
.Except(notFilters)
.Select(CreateTerm));
}
else
{
request.PostFilter.Bool.Must.AddRange(
setup.Filters
.Except(notFilters)
.Where(f => f.Operator == Operator.And && !f.Not)
.Select(CreateTerm));
request.PostFilter.Bool.Should.AddRange(
setup.Filters
.Except(notFilters)
.Where(f => f.Operator == Operator.Or && !f.Not)
.Select(CreateTerm));
}
}
if (filterQuery.HasAnyValues())
{
request.Query.Bool.Filter.Add(filterQuery);
}
AppendDefaultFilters(request.Query, setup.Type);
if (request.Query.Bool.Should.Count > 1 && request.Query.Bool.Must.Count == 0)
{
request.Query.Bool.MinimumNumberShouldMatch = 1;
}
else
{
request.Query.Bool.MinimumNumberShouldMatch = null;
}
if (request.PostFilter.Bool.Should.Count > 0 && request.PostFilter.Bool.Must.Count == 0)
{
request.PostFilter.Bool.MinimumNumberShouldMatch = 1;
}
else
{
request.PostFilter.Bool.MinimumNumberShouldMatch = null;
}
}
public QueryRequest GetPageTypeInstancesQueryRequest(Guid pageTypeId, Guid languageId, SecurityToken token)
{
// Set up page query.
var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token);
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId));
// Only published pages.
request.FilterTags.Add(new Tag(TagNames.IsPublished, true));
// Sort order.
Sorting sorting = new Sorting(TagNames.PageIndex, SortingFieldType.Int);
request.Sortings.Add(sorting);
// Fetch many.
request.Paging = new Paging(1, 999999);
return request;
}
public virtual Task <IEnumerable <AlarmDeviceStateView> > GetAlarmState(QueryRequest request, CancellationToken cancellationToken)
{
return(DataSource?.GetAlarmState(request, cancellationToken) ?? Task.FromResult(new List <AlarmDeviceStateView>().AsEnumerable()));
}
private void DoQuery(QueryRequest request)
{
object data = null;
Exception exception = null;
try
{
data = request.DataProducer();
}
catch (Exception e)
{
exception = e;
}
//if (!System.Windows.Application.Current.Dispatcher.CheckAccess())
// System.Windows.Application.Current.Dispatcher.Invoke(
// new Action(() => { IsBusy = false; }),
// new object[] { });
if (!this._endInitCompete && exception != null) this._endInitError = true;
//如果没有取消，则继续通知更改。
if (request.Version == this._queryVersion)
{
//把结果返回到基类中。
this.OnQueryFinished(data, exception, o => { this.IsBusy = false; return null; }, null);
}
}
private static QueryResults DoWork_Query(QueryRequest req, CancellationToken cancel)
{
try
{
using (SqlConnection connection = new SqlConnection(req.ConnectionString))
{
if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled");
connection.Open();
if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled");
using (SqlCommand command = new SqlCommand(req.SQLStatement, connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled");
string[] columnNames = null;
List<string[]> rows = new List<string[]>();
while (reader.Read())
{
if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled");
// Column Names
if (columnNames == null)
{
columnNames = new string[reader.VisibleFieldCount];
for (int cntr = 0; cntr < reader.VisibleFieldCount; cntr++)
{
columnNames[cntr] = reader.GetName(cntr);
}
}
// Row Values
string[] row = new string[reader.VisibleFieldCount];
for (int cntr = 0; cntr < reader.VisibleFieldCount; cntr++)
{
row[cntr] = reader.GetValue(cntr).ToString();
}
rows.Add(row);
}
if (cancel.IsCancellationRequested) return new QueryResults(req.ConnectionString, req.SQLStatement, "cancelled");
if (rows.Count == 0)
{
return new QueryResults(req.ConnectionString, req.SQLStatement, "No rows found");
}
else
{
return new QueryResults(req.ConnectionString, req.SQLStatement, columnNames, rows.ToArray());
}
}
}
}
}
catch (Exception ex)
{
return new QueryResults(req.ConnectionString, req.SQLStatement, ex.Message);
}
}
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(List<Metadata> requiredMetadatas, List<Metadata> optionalMetadatas, Guid parentPageId, Guid webSiteId, SortType sortType, int pageIndex, int pageSize, Guid languageId, SecurityToken token)
{
var request = new QueryRequest(languageId, SearchDomains.Pages, token);
// Make sure page is searchable
request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString));
// Make sure pages are published
request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString));
if (parentPageId != Guid.Empty)
{
// Only search pages under specified page
request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId));
}
if (webSiteId != Guid.Empty)
{
// Only search pages under specified web site
request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId));
}
// Add required metadatas as filter
foreach (Metadata metadata in requiredMetadatas)
{
request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID));
}
if (optionalMetadatas != null && optionalMetadatas.Count > 0)
{
// Add optional metadatas
OptionalTagClause optionalMetadatasClause = new OptionalTagClause();
foreach (Metadata metadata in optionalMetadatas)
{
optionalMetadatasClause.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID));
}
request.FilterTags.Add(optionalMetadatasClause);
}
request.Paging = GetPaging(pageIndex, pageSize);
Sorting sorting = GetSortType(sortType);
if (sorting != null)
{
request.Sortings.Add(sorting);
}
return request;
}
public async Task <List <CheckPoint> > ParseLocationHistoryAsync(LocationHistory locationHistory, QueryRequest model, ProgressChangedEventHandler callback)
{
var locations = BorderCrossingHelper.PrepareLocations(locationHistory, model.IntervalType);
var filteredLocations = locations.Where(l => l.Date >= model.StartDate && l.Date <= model.EndDate).OrderBy(l => l.TimestampMsUnix).ToList();
var currentLocation = filteredLocations.First();
var currentCountry = GetCountryName(currentLocation.Point);
var i = 0;
var count = filteredLocations.Count();
var checkPoints = new List <CheckPoint>
{
BorderCrossingHelper.LocationToCheckPoint(currentLocation, currentCountry)
};
foreach (var location in filteredLocations)
{
await Task.Run(() =>
{
i++;
callback(this, new ProgressChangedEventArgs((int)(100.0 * i / count), null));
var countryName = GetCountryName(location.Point);
if (currentCountry == countryName)
{
currentLocation = location;
return;
}
var range = locationHistory.Locations.Where(lh => lh.TimestampMsUnix >= currentLocation.TimestampMsUnix && lh.TimestampMsUnix <= location.TimestampMsUnix).ToList();
var checkPoint = BorderCrossingHelper.FindCheckPoint(range, currentLocation, currentCountry, location, countryName, GetCountryName);
checkPoints.Add(checkPoint);
currentCountry = countryName;
currentLocation = location;
});
}
var last = filteredLocations.Last();
checkPoints.Add(BorderCrossingHelper.LocationToCheckPoint(last, GetCountryName(last.Point)));
return(checkPoints);
}
public Hashtable GetItem(Hashtable State, string tableName, string PrimaryKeyValue, string RangeKeyValue)
{
if (State["DynamoDBClient"] == null)
SetupClient(State);
AmazonDynamoDB client = (AmazonDynamoDB)State["DynamoDBClient"];
var request = new QueryRequest
{
TableName = tableName,
HashKeyValue = new AttributeValue { S = PrimaryKeyValue },
// Optional parameters.
RangeKeyCondition = new Condition
{
ComparisonOperator = "EQ",
AttributeValueList = new List<AttributeValue>()
{
new AttributeValue { S = RangeKeyValue }
}
},
ConsistentRead = true
};
var response = client.Query(request);
foreach (Dictionary<string, AttributeValue> item
in response.QueryResult.Items)
{
Hashtable map = new Hashtable();
foreach (string key in item.Keys)
{
AttributeValue value = item[key];
map[key] = value.S;
}
return map;
}
return null;
}
/// <remarks/>
public System.IAsyncResult BeginQuery(QueryRequest queryRequest, System.AsyncCallback callback, object asyncState)
{
return(this.BeginInvoke("Query", new object[] {
queryRequest
}, callback, asyncState));
}
public ArrayList GetItems(Hashtable State, string tableName, string PrimaryKeyValue)
{
ArrayList output = new ArrayList();
try
{
if (State["DynamoDBClient"] == null)
SetupClient(State);
AmazonDynamoDB client = (AmazonDynamoDB)State["DynamoDBClient"];
var request = new QueryRequest
{
TableName = tableName,
HashKeyValue = new AttributeValue { S = PrimaryKeyValue }
};
var response = client.Query(request);
foreach (Dictionary<string, AttributeValue> item in response.QueryResult.Items)
{
Hashtable map = new Hashtable();
foreach (string key in item.Keys)
{
AttributeValue value = item[key];
map[key] = value.S;
}
output.Add(map);
}
}
catch (Exception ex)
{
string error = ex.Message;
return null;
}
return output;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryRequestTests"/> class.
/// </summary>
public QueryRequestTests()
{
var query = new QueryableSource <object>(Expression.Constant(this.query));
testClass = new QueryRequest(query);
}
/// <summary>
/// Overridden. Starts to create the requested object,
/// either immediately or on a background thread,
/// based on the value of the IsAsynchronous property.
/// </summary>
protected override void BeginQuery()
{
if (_init)
return;
if (_firstRun)
{
_firstRun = false;
if (!IsInitialLoadEnabled)
return;
}
if (_endInitError)
{
// this handles a case where the WPF form initilizer
// invokes the data provider twice when an exception
// occurs - we really don't want to try the query twice
// or report the error twice
_endInitError = false;
OnQueryFinished(null);
return;
}
if (this.IsRefreshDeferred)
return;
QueryRequest request = new QueryRequest();
request.ObjectType = _objectType;
request.FactoryMethod = _factoryMethod;
request.FactoryParameters = _factoryParameters;
request.ManageObjectLifetime = _manageLifetime;
IsBusy = true;
if (IsAsynchronous)
System.Threading.ThreadPool.QueueUserWorkItem(DoQuery, request);
else
DoQuery(request);
}
public static async Task <PagingData <T> > AsPagingData <T>(this IAsyncEnumerable <T> data, QueryRequest query, QueryStatistic statistic)
{
return((await data.ToArrayAsync().ConfigureAwait(false)).AsPagingData(query, statistic));
}
/// <summary>
/// Waits until that the schema version in all nodes is the same or the waiting time passed.
/// This method blocks the calling thread.
/// </summary>
internal void WaitForSchemaAgreement(Connection connection)
{
if (Hosts.Count == 1)
{
//If there is just one node, the schema is up to date in all nodes :)
return;
}
var start = DateTime.Now;
var waitSeconds = _config.ProtocolOptions.MaxSchemaAgreementWaitSeconds;
Logger.Info("Waiting for schema agreement");
try
{
var totalVersions = 0;
while (DateTime.Now.Subtract(start).TotalSeconds < waitSeconds)
{
var schemaVersionLocalQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionLocal, false, QueryProtocolOptions.Default);
var schemaVersionPeersQuery = new QueryRequest(connection.ProtocolVersion, SelectSchemaVersionPeers, false, QueryProtocolOptions.Default);
var queries = new [] { connection.Send(schemaVersionLocalQuery), connection.Send(schemaVersionPeersQuery) };
// ReSharper disable once CoVariantArrayConversion
Task.WaitAll(queries, _config.ClientOptions.QueryAbortTimeout);
var versions = new HashSet<Guid>
{
Cassandra.ControlConnection.GetRowSet(queries[0].Result).First().GetValue<Guid>("schema_version")
};
var peerVersions = Cassandra.ControlConnection.GetRowSet(queries[1].Result).Select(r => r.GetValue<Guid>("schema_version"));
foreach (var v in peerVersions)
{
versions.Add(v);
}
totalVersions = versions.Count;
if (versions.Count == 1)
{
return;
}
Thread.Sleep(500);
}
Logger.Info(String.Format("Waited for schema agreement, still {0} schema versions in the cluster.", totalVersions));
}
catch (Exception ex)
{
//Exceptions are not fatal
Logger.Error("There was an exception while trying to retrieve schema versions", ex);
}
}
public async Task <IReadOnlyList <ResourceDto> > GetSqlResourcesAsync(string _subscriptionId)
{
if (string.IsNullOrWhiteSpace(_subscriptionId))
{
return(null);
}
DefaultAzureCredential credential;
if (_sqlResourceInventoryConfiguration.UseSystemAssignedManagedIdentity)
{
credential = new DefaultAzureCredential();
}
else
{
credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions {
ManagedIdentityClientId = _sqlResourceInventoryConfiguration.UserAssignedManagedIdentityClientId
});
}
TokenRequestContext tokenRequestContext = new TokenRequestContext(new[] { Constants.AzureResourceManagerAPIDefaultScope });
AccessToken tokenRequestResult = await credential.GetTokenAsync(tokenRequestContext);
ServiceClientCredentials serviceClientCreds = new TokenCredentials(tokenRequestResult.Token);
ResourceGraphClient argClient = new ResourceGraphClient(serviceClientCreds);
QueryRequest request = new QueryRequest();
request.Subscriptions = new List <string>()
{
_subscriptionId
};
request.Query = "Resources |" +
" where type in ('microsoft.sql/servers','microsoft.sqlvirtualmachine/sqlvirtualmachines','Microsoft.Sql/managedInstances') |" +
" project id, name, type, location, resourceGroup, subscriptionId, tenantId";
request.Options = new QueryRequestOptions()
{
ResultFormat = ResultFormat.ObjectArray
};
// Parameter to hold full list of returned resources
List <ResourceDto> results = new List <ResourceDto>();
// Send query to the ResourceGraphClient and get response
QueryResponse response = argClient.Resources(request);
// IMPORTANT: The query must project the id field in order for pagination to work.
// If it's missing from the query, the response won't include the $skipToken.
if (response.Count > 0)
{
// Add response results to list
results.AddRange(((JArray)response.Data).ToObject <List <ResourceDto> >());
// Continue till SkipToken is null
while (!string.IsNullOrWhiteSpace(response.SkipToken))
{
// Update request with new skip token returned from response
request.Options.SkipToken = response.SkipToken;
// Send query with SkipToken to the ResourceGraphClient and get response
response = argClient.Resources(request);
// Add response results to list
results.AddRange(((JArray)response.Data).ToObject <List <ResourceDto> >());
}
}
IReadOnlyList <ResourceDto> returnList = results.ToList().AsReadOnly();
return(returnList);
}
public List<Guid> GetMetadataIdList(QueryRequest request)
{
SearchResponse response = Solution.Instance.SearchService.Search(request);
return response.Hits.Select(hit => new Guid(hit.Id)).ToList();
}
private void SetupBoosting(QuerySetup setup, QueryRequest request)
{
if (!setup.UseBoosting)
{
return;
}
List <Boost> boosting = GetBoosting(setup.Type, setup.BoostFields);
if (boosting.Count > 0)
{
var searchText = request.Query.SearchText.Replace("*", String.Empty);
if (!TextUtil.IsNumeric(searchText))
{
boosting.RemoveAll(b => b.FieldName.Equals(DefaultFields.Id));
}
request.Query.Bool.Should.AddRange(
boosting.Select(b =>
new MatchWithBoost(b.FieldName,
searchText, b.Weight, setup.Operator)));
}
// Boosting by type
if (setup.BoostTypes.Count > 0)
{
request.Query.Bool.Should.AddRange(
setup.BoostTypes.Select(b =>
new MatchWithBoost(DefaultFields.Types, b.Key.GetTypeName(), b.Value, setup.Operator)));
// Direct match in Type gives higher score than match in Types, hence the +1
request.Query.Bool.Should.AddRange(
setup.BoostTypes.Select(b =>
new MatchWithBoost(DefaultFields.Type, b.Key.GetTypeName(), b.Value + 1, setup.Operator)));
}
if (setup.BoostAncestors.Count > 0)
{
request.Query.Bool.Should.AddRange(
setup.BoostAncestors.Select(b =>
new MatchWithBoost(DefaultFields.Path, b.Key.ToString(), b.Value, setup.Operator)));
request.Query.Bool.Should.AddRange(
setup.BoostAncestors.Select(b =>
new MatchWithBoost(DefaultFields.Id, b.Key.ToString(), b.Value, setup.Operator)));
}
// Best Bets
if (setup.UseBestBets && !String.IsNullOrWhiteSpace(request.Query.SearchText))
{
IEnumerable <string> terms = request.Query.SearchText
.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(t => t.Trim().Trim('*'));
var key = setup.IndexName ?? _settings.GetDefaultIndexName(Language.GetLanguageCode(setup.Language));
if (!Conventions.Indexing.BestBets.TryGetValue(key, out var bestBetsForLanguage))
{
return;
}
IEnumerable <BestBet> bestBets = bestBetsForLanguage
.Where(b => b.Terms.Any(t => terms.Contains(t)));
request.Query.Bool.Should.AddRange(
bestBets.Select(_ =>
new MatchWithBoost(
DefaultFields.BestBets, request.Query.SearchText.Trim('*'), BestBetMultiplier, setup.Operator)));
}
}
/// <summary>
/// Gets <see cref="Metadata"/> with complete set of information.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="searchService">The search service.</param>
/// <param name="permissionManager">The permission manager.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public List<Metadata> GetMetadatas(QueryRequest request, Litium.Foundation.Modules.CMS.Security.PermissionManager permissionManager, SecurityToken token)
{
// Perform search
SearchResponse response = Solution.Instance.SearchService.Search(request);
if (response == null)
{
_log.Error("Search returned null instead of zero results.");
return new List<Metadata>();
}
List<Page> pages = GetPagesFromSearchResponse(response, permissionManager, token);
List<Metadata> mds = new List<Metadata>();
foreach (Page page in pages)
{
mds.Add(new Metadata(page, this, token));
}
return mds;
}
public async Task <ActionResult> PerformQuery([FromBody] QueryRequest request)
{
QueryResponse res = await DomainService.ServiceGetData(request);
return(new ChunkedResult <QueryResponse>(res, DomainService.Serializer));
}
public static async Task <QueryResponse <TModel> > QueryContent <TModel>(this ISquidexContentClient that, string app, string schema, QueryRequest request)
{
dynamic raw = await that.QueryContent(app, schema, request.Top, request.Skip, request.OrderBy, request.Search, request.Filter);
var deserialized = JsonConvert.DeserializeObject <QueryResponse <TModel> >(raw.ToString());
return(deserialized);
}
public virtual Task <IEnumerable <GrafanaAdapters.AlarmState> > GetDeviceAlarms(QueryRequest request, CancellationToken cancellationToken)
{
return(DataSource?.GetDeviceAlarms(request, cancellationToken) ?? Task.FromResult(new List <GrafanaAdapters.AlarmState>().AsEnumerable()));
}
public IQueryResult <IQueryPlan> Prepare(string statementToPrepare)
{
IQueryRequest query = new QueryRequest(statementToPrepare);
return(Prepare(query));
}
public virtual Task <List <GrafanaAlarm> > GetAlarms(QueryRequest request, CancellationToken cancellationToken)
{
return(DataSource?.GetAlarms(request, cancellationToken) ?? Task.FromResult(new List <GrafanaAlarm>()));
}
public override void Query(Google.ProtocolBuffers.IRpcController controller, QueryRequest request, Action<QueryResponse> done) {
throw new NotImplementedException();
}
public static void RetrieveData(PredictorTrainingContext ctx)
{
using (HeavyProfiler.Log("RetrieveData"))
{
ctx.ReportProgress($"Executing MainQuery for {ctx.Predictor}");
QueryRequest mainQueryRequest = GetMainQueryRequest(ctx.Predictor.MainQuery);
ResultTable mainResult = QueryLogic.Queries.ExecuteQuery(mainQueryRequest);
ctx.MainQuery = new MainQuery
{
QueryRequest = mainQueryRequest,
ResultTable = mainResult,
};
if (!mainQueryRequest.GroupResults)
{
ctx.MainQuery.GetParentKey = (ResultRow row) => new object[] { row.Entity };
}
else
{
var rcs = mainResult.Columns.Where(a => !(a.Column.Token is AggregateToken)).ToArray();
ctx.MainQuery.GetParentKey = (ResultRow row) => row.GetValues(rcs);
}
var algorithm = PredictorLogic.Algorithms.GetOrThrow(ctx.Predictor.Algorithm);
ctx.SubQueries = new Dictionary <PredictorSubQueryEntity, SubQuery>();
foreach (var sqe in ctx.Predictor.SubQueries)
{
ctx.ReportProgress($"Executing SubQuery {sqe}");
QueryRequest queryGroupRequest = ToMultiColumnQuery(ctx.Predictor.MainQuery, sqe);
ResultTable groupResult = QueryLogic.Queries.ExecuteQuery(queryGroupRequest);
var pairs = groupResult.Columns.Zip(sqe.Columns, (rc, sqc) => (rc, sqc)).ToList();
var parentKeys = pairs.Extract(a => a.sqc.Usage == PredictorSubQueryColumnUsage.ParentKey).Select(a => a.rc).ToArray();
var splitKeys = pairs.Extract(a => a.sqc.Usage == PredictorSubQueryColumnUsage.SplitBy).Select(a => a.rc).ToArray();
var values = pairs.Select(a => a.rc).ToArray();
var groupedValues = groupResult.Rows.AgGroupToDictionary(
row => row.GetValues(parentKeys),
gr => gr.ToDictionaryEx(
row => row.GetValues(splitKeys),
row => row.GetValues(values),
ObjectArrayComparer.Instance));
ctx.SubQueries.Add(sqe, new SubQuery
{
SubQueryEntity = sqe,
QueryGroupRequest = queryGroupRequest,
ResultTable = groupResult,
GroupedValues = groupedValues,
SplitBy = splitKeys,
ValueColumns = values,
ColumnIndexToValueIndex = values.Select((r, i) => KeyValuePair.Create(r.Index, i)).ToDictionary()
});
}
ctx.ReportProgress($"Creating Columns");
var codifications = new List <PredictorCodification>();
using (HeavyProfiler.Log("MainQuery"))
{
for (int i = 0; i < mainResult.Columns.Length; i++)
{
var col = ctx.Predictor.MainQuery.Columns[i];
using (HeavyProfiler.Log("Columns", () => col.Token.Token.ToString()))
{
var mainCol = new PredictorColumnMain(col, i);
var mainCodifications = algorithm.GenerateCodifications(col.Encoding, mainResult.Columns[i], mainCol);
codifications.AddRange(mainCodifications);
}
}
}
foreach (var sq in ctx.SubQueries.Values)
{
using (HeavyProfiler.Log("SubQuery", () => sq.ToString() !))
{
var distinctKeys = sq.GroupedValues.SelectMany(a => a.Value.Keys).Distinct(ObjectArrayComparer.Instance).ToList();
distinctKeys.Sort(ObjectArrayComparer.Instance);
foreach (var ks in distinctKeys)
{
using (HeavyProfiler.Log("Keys", () => ks.ToString(k => k?.ToString(), ", ")))
{
foreach (var vc in sq.ValueColumns)
{
var col = sq.SubQueryEntity.Columns[vc.Index];
using (HeavyProfiler.Log("Columns", () => col.Token.Token.ToString()))
{
var subCol = new PredictorColumnSubQuery(col, vc.Index, sq.SubQueryEntity, ks);
var subQueryCodifications = algorithm.GenerateCodifications(col.Encoding, vc, subCol);
codifications.AddRange(subQueryCodifications);
}
}
}
}
}
}
ctx.SetCodifications(codifications.ToArray());
}
}
/// <summary>
/// Get a metadata by its name.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="token">The security token.</param>
/// <returns></returns>
public Metadata GetMetadata(QueryRequest request, SecurityToken token)
{
SearchResponse response = Solution.Instance.SearchService.Search(request);
if (response != null)
{
if (response.Hits.Count > 0)
{
foreach (Hit hit in response.Hits)
{
Guid pageId = new Guid(hit.Id);
if (Page.ExistsPage(pageId))
{
Page page = Page.GetFromID(pageId, token);
return new Metadata(page, this, token);
}
}
}
}
else
{
_log.Error("Search returned null instead of zero results.");
}
return null;
}
public ResultTable ExecuteQuery(QueryRequest request)
{
return(Execute(ExecuteType.ExecuteQuery, request.QueryName, request, dqb => dqb.Core.Value.ExecuteQuery(request)));
}
public ListResponse<PharmacyDto> GetMatchingPharmacies(QueryRequest<PharmacyQuery> request)
{
try
{
using (var dbContext = new AptekaNETDbContext())
{
var pharmacies = dbContext.Pharmacies.AsEnumerable().Where(p => request.Query.IsMatch(p)).ToList();
if (pharmacies.Any())
{
var pharmacyDtos = pharmacies.Select(p => _pharmacyAssembler.ToDto(p)).ToList();
return new ListResponse<PharmacyDto>(request.Id, pharmacyDtos)
{
Message = "Pobrano pomyślnie"
};
}
return new ListResponse<PharmacyDto>(request.Id, new List<PharmacyDto>())
{
Message = "Nie ma apteki spełniającej powyższe warunki"
};
}
}
catch (Exception e)
{
return new ListResponse<PharmacyDto>(request.Id, new List<PharmacyDto>())
{
Message = "Błąd"
};
}
}
public ListResponse<OrderIngredientDTO> QueryIngredients(QueryRequest<IngredientsQuery> request)
{
if (request.Query.IngredientIds == null)
throw PizzaServiceFault.Create(Messages.NO_DATA);
return db.inTransaction(uow =>
{
return ListResponse.Create(uow.Db.Ingredients.Find(request.Query.IngredientIds).ToList()
.Select(ingAssembler.ToOrderIngredientDto).ToList());
});
}
public System.IAsyncResult BeginlistTemplates(QueryRequest listTemplates, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("listTemplates", new object[] {
listTemplates}, callback, asyncState);
}
public virtual async Task <IHttpActionResult> Query(HttpRequestMessage request, QueryRequest query)
{
var svc = DataService;
if (svc == null)
{
var response = Request.CreateResponse(HttpStatusCode.NotFound, "Service not found");
throw new HttpResponseException(response);
}
var res = await svc.ServiceGetData(query).ConfigureAwait(false);
return(new ChunkedActionResult <QueryResponse>(request, res, _serializer));
}
/// <summary>
/// Queries the resources managed by Azure Resource Manager for all
/// subscriptions specified in the request.
/// <see href="https://aka.ms/resource-graph/learntoquery" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='query'>
/// Request specifying query and its options.
/// </param>
public static QueryResponse Resources(this IResourceGraphClient operations, QueryRequest query)
{
return(operations.ResourcesAsync(query).GetAwaiter().GetResult());
}
public static QueryResponse Query(this IAmazonDynamoDB client, QueryRequest request)
{
return(client.QueryAsync(request).GetResult());
}
/// <summary>
/// Queries the resources managed by Azure Resource Manager for all
/// subscriptions specified in the request.
/// <see href="https://aka.ms/resource-graph/learntoquery" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='query'>
/// Request specifying query and its options.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <QueryResponse> ResourcesAsync(this IResourceGraphClient operations, QueryRequest query, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ResourcesWithHttpMessagesAsync(query, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <remarks/>
public void QueryAsync(QueryRequest queryRequest)
{
this.QueryAsync(queryRequest, null);
}
public Task <HttpResponse <QueryTransactionResponse> > QueryTransactionAsync(QueryRequest requestModel)
{
return(_apiHttpClient.PostRequest <QueryTransactionResponse>(_configuration.ApiUrls.ReportingTransactions, _configuration.SecretKey, requestModel));
}
public QueryResult ExecuteQuery(QueryRequest gql, TContextType context, IServiceProvider serviceProvider, ClaimsIdentity claims, IMethodProvider methodProvider = null)
{
return(ExecuteQueryAsync(gql, context, serviceProvider, claims, methodProvider).Result);
}
public Task <HttpResponse <QueryChargebackResponse> > QueryChargebackAsync(QueryRequest requestModel)
{
return(_apiHttpClient.PostRequest <QueryChargebackResponse>(_configuration.ApiUrls.ReportingChargebacks, _configuration.SecretKey, requestModel));
}
public static void Main(string[] args)
{
// connect to couchbase cluster and get a bucket
// this example assumes a couchbase node running locally
// this example assumes a bucket exists called 'default
var client = new ClientConfiguration {
Servers = new List <Uri> {
new Uri("couchbase://localhost")
}
};
ClusterHelper.Initialize(client);
var bucket = ClusterHelper.GetBucket("default");
// create some documents that *don't* have a 'processed' field
// tag::createdocuments[]
for (var i = 0; i < 5; i++)
{
var docKey = Guid.NewGuid().ToString();
var docContent = new {
foo = "bar",
type = "example",
processed = false,
dt = DateTime.Now
};
var docContentJson = JsonConvert.SerializeObject(docContent);
bucket.Insert(new Document <dynamic> {
Id = docKey,
Content = docContent
});
Console.WriteLine($"Inserted: {docKey} - {docContentJson}");
}
// end::createdocuments[]
Console.WriteLine();
// update all 'example' documents, setting a 'processed' field to true
// and use RETURNING keyword to get the documents that were processed
// Note that you need (at least) a primary key index on the default
// tag::updatereturning[]
var n1ql = @"UPDATE `default` d
SET processed = true
WHERE d.type = 'example'
AND d.processed = false
RETURNING d.*, META().id AS docKey";
var query = QueryRequest.Create(n1ql);
query.ScanConsistency(ScanConsistency.RequestPlus);
var results = bucket.Query <dynamic>(query);
// end::updatereturning[]
if (!results.Success)
{
Console.WriteLine("There was an error.");
Console.WriteLine(results.Message);
results.Errors.ForEach(e => Console.WriteLine(e.Message));
}
// the results should be the same five documents created initially (but with processed fields)
// tag::showreturning[]
foreach (var result in results.Rows)
{
var resultJson = JsonConvert.SerializeObject(result);
Console.WriteLine($"Returned: {resultJson}");
}
// end::showreturning[]
}
/// <summary>
/// Serializes QueryRequest to an XML stream.
/// </summary>
/// <param name="writer">XML stream to write.</param>
/// <param name="queryRequest">QueryRequest.</param>
/// <returns>XML stream with the QueryRequest.</returns>
public static XmlWriter Serialize(XmlWriter writer, QueryRequest queryRequest)
{
writer.WriteStartElement(DTD.Request.TagQueryRequest);
writer.WriteAttributeString(DTD.Request.QueryRequest.TagClass, queryRequest.Class);
writer.WriteAttributeString(DTD.Request.QueryRequest.TagDisplaySet, queryRequest.DisplayItems);
if (queryRequest.IsQueryInstance)
{
XMLQueryInstanceSerializer.Serialize(writer, queryRequest.QueryInstance);
}
else
{
if (queryRequest.IsQueryFilter)
{
XMLQueryFilterSerializer.Serialize(writer, queryRequest.QueryFilter);
}
else
{
if (queryRequest.IsQueryRelated)
{
XMLQueryRelatedSerializer.Serialize(writer, queryRequest.QueryRelated);
}
}
}
if (queryRequest.OrderCriteria.Length > 0)
{
writer.WriteStartElement(DTD.Request.QueryRequest.TagSort);
writer.WriteAttributeString(DTD.Request.QueryRequest.TagSortCriterium, queryRequest.OrderCriteria);
writer.WriteEndElement();
}
if (queryRequest.NavigationalFiltering != null)
{
XMLNavigationFilteringSerializer.Serialize(writer, queryRequest.NavigationalFiltering);
}
writer.WriteEndElement();
return writer;
}
/// <summary>
/// Sets the keyspace of the connection.
/// If the keyspace is different from the current value, it sends a Query request to change it
/// </summary>
public Task<bool> SetKeyspace(string value)
{
if (String.IsNullOrEmpty(value) || _keyspace == value)
{
//No need to switch
return TaskHelper.Completed;
}
Task<bool> keyspaceSwitch;
try
{
if (!_keyspaceSwitchSemaphore.Wait(0))
{
//Could not enter semaphore
//It is very likely that the connection is already switching keyspace
keyspaceSwitch = _keyspaceSwitchTask;
if (keyspaceSwitch != null)
{
return keyspaceSwitch.Then(_ =>
{
//validate if the new keyspace is the expected
if (_keyspace != value)
{
//multiple concurrent switches to different keyspace
return SetKeyspace(value);
}
return TaskHelper.Completed;
});
}
_keyspaceSwitchSemaphore.Wait();
}
}
catch (ObjectDisposedException)
{
//The semaphore was disposed, this connection is closed
return TaskHelper.FromException<bool>(new SocketException((int) SocketError.NotConnected));
}
//Semaphore entered
if (_keyspace == value)
{
//While waiting to enter the semaphore, the connection switched keyspace
try
{
_keyspaceSwitchSemaphore.Release();
}
catch (ObjectDisposedException)
{
//this connection is now closed but the switch completed successfully
}
return TaskHelper.Completed;
}
var request = new QueryRequest(ProtocolVersion, string.Format("USE \"{0}\"", value), false, QueryProtocolOptions.Default);
_logger.Info("Connection to host {0} switching to keyspace {1}", Address, value);
keyspaceSwitch = _keyspaceSwitchTask = Send(request).ContinueSync(r =>
{
_keyspace = value;
try
{
_keyspaceSwitchSemaphore.Release();
}
catch (ObjectDisposedException)
{
//this connection is now closed but the switch completed successfully
}
_keyspaceSwitchTask = null;
return true;
});
return keyspaceSwitch;
}
static async Task Main(string[] args)
{
var continueOp = true;
var justFirstTime = true;
int?trackId = null;
var request = default(object);
while (continueOp)
{
if (justFirstTime)
{
PrintInfo();
justFirstTime = false;
}
var trackIdText = trackId.HasValue ? $"(trackId = {trackId})" : "";
Write($"operation {trackIdText} -> ");
var op = ReadLine();
switch (op.ToUpper())
{
case "R":
WriteLine("Reset traking Id", ConsoleColor.Cyan);
trackId = null;
break;
case "U":
WriteLine("Using a traking Id", ConsoleColor.Cyan);
if (!TryInputInt("trackId", out int trackIdPased))
{
break;
}
if (trackIdPased <= 0)
{
WriteLine("The trackId should be positive");
break;
}
trackId = trackIdPased;
break;
case "D":
WriteLine("Divide", ConsoleColor.Cyan);
if (!TryInputInt("dividend", out int dividend))
{
break;
}
if (!TryInputInt("divisor", out int divisor))
{
break;
}
request = new DivRequest()
{
Dividend = dividend, Divisor = divisor
};
await PostAndPrint("div", request, trackId);
break;
case "M":
WriteLine("Multiplication", ConsoleColor.Cyan);
if (!TryInputListInt(out List <int> toSend))
{
break;
}
request = new MultRequest()
{
Factors = toSend
};
await PostAndPrint("mult", request, trackId);
break;
case "Q":
WriteLine("Square", ConsoleColor.Cyan);
if (!TryInputInt("number", out int number))
{
break;
}
request = new SqrtRequest()
{
Number = number
};
await PostAndPrint("sqrt", request, trackId);
break;
case "S":
WriteLine("Substract", ConsoleColor.Cyan);
if (!TryInputInt("minuend", out int minuend))
{
break;
}
if (!TryInputInt("subtrahend", out int subtrahend))
{
break;
}
request = new SubRequest()
{
Minuend = minuend, Subtrahend = subtrahend
};
await PostAndPrint("sub", request, trackId);
break;
case "A":
WriteLine("Sum", ConsoleColor.Cyan);
if (!TryInputListInt(out toSend))
{
break;
}
request = new SumRequest()
{
Addends = toSend
};
await PostAndPrint("add", request, trackId);
break;
case "G":
WriteLine("Query", ConsoleColor.Cyan);
if (!TryInputInt("trackId", out int trackIdToSend))
{
break;
}
request = new QueryRequest()
{
Id = trackIdToSend
};
await PostAndPrint("query", request, trackId);
break;
case "O":
WriteLine("Operations", ConsoleColor.Cyan);
await GetAndPrint("operations");
break;
case "E":
continueOp = false;
break;
case "I":
PrintInfo();
break;
default:
WriteLine("Invalid operation!", ConsoleColor.Red);
break;
}
}
WriteLine("Bye :)");
}
public override void Query(IRpcController controller, QueryRequest request, Action<QueryResponse> done)
{
ProtoOutputBuffer.Write(request.GetType(), request.ToString());
}
public ListResponse<OrderIngredientDTO> QueryIngredients(QueryRequest<IngredientsQuery> req)
{
if (req.Query.Login != "Admin") throw new FaultException<PizzaServiceFault>(new PizzaServiceFault("wrong user"));
var list = new List<OrderIngredientDTO>();
foreach (var i in req.Query.IngredientIds)
list.Add(new OrderIngredientDTO()
{
Name = String.Format("Ingredient {0}",i),
IngredientID = i
});
return new ListResponse<OrderIngredientDTO>(list);
}
