protected Result FormatResult( QueryResponse<ElasticSearchProduct> response ) { var result = new Result { Products = response.Documents }; this.FormatFacets( response, result ); return result; }
protected void TestDefaultAssertions(QueryResponse<ElasticSearchProject> queryResponse) { Assert.True(queryResponse.IsValid); Assert.NotNull(queryResponse.ConnectionStatus); Assert.Null(queryResponse.ConnectionStatus.Error); Assert.True(queryResponse.Total > 0, "No hits"); Assert.True(queryResponse.Documents.Any()); Assert.True(queryResponse.Documents.Count() > 0); Assert.True(queryResponse.Shards.Total > 0); Assert.True(queryResponse.Shards.Successful == queryResponse.Shards.Total); Assert.True(queryResponse.Shards.Failed == 0); }
protected void TestDefaultAssertions(QueryResponse<ElasticSearchProject> queryResponse) { Assert.True(queryResponse.IsValid, "response is not valid"); Assert.NotNull(queryResponse.ConnectionStatus, "connection status is null"); Assert.Null(queryResponse.ConnectionStatus.Error, "connection status error is null"); Assert.True(queryResponse.Total > 0, "Query yielded no results as indicated by total returned from ES"); Assert.True(queryResponse.Documents.Any(), "documents.any() is false"); Assert.True(queryResponse.Documents.Count() > 0, "documents.count is 0"); Assert.True(queryResponse.Shards.Total > 0, "did not hit any shard"); Assert.True(queryResponse.Shards.Successful == queryResponse.Shards.Total, "Not all the shards were hit succesfully"); Assert.True(queryResponse.Shards.Failed == 0, "shards failed is not null"); }
protected void TestDefaultAssertions(QueryResponse<ElasticSearchProject> queryResponse) { Assert.True(queryResponse.IsValid); Assert.Null(queryResponse.ConnectionError); Assert.True(queryResponse.Total > 0, "No hits"); Assert.True(queryResponse.Documents.Any()); Assert.True(queryResponse.Documents.Count() > 0); Assert.True(queryResponse.Shards.Total > 0); Assert.True(queryResponse.Shards.Successful == queryResponse.Shards.Total); Assert.True(queryResponse.Shards.Failed == 0); Assert.That(queryResponse.ElapsedMilliseconds, Is.InRange(0, 200)); }
protected Message( ushort transactionId, ushort flags, QueryResponse queryResponse, OpCode opCode, NsFlags nsFlags, RCode rCode, ushort questions, ushort answerRRs, ushort authorityRRs, string name, NsType nsType, NsClass nsClass, List<Record> additionalRecords) { }
public byte[] Query(byte[] requestData) { object result = null; try { QueryRequest request = (QueryRequest)Deserialize(requestData); IDataAccess dao = DataAccessFactory.Create(request.ObjectType); object[] objs = dao.Query(request.Sql); result = new QueryResponse() { Result = objs }; } catch (Exception ex) { result = ex; } return Serialize(result); }
protected Result FormatFacets( QueryResponse<ElasticSearchProduct> response, Result result ) { if( response.Facets == null ) return result; foreach( var facet in response.Facets ) { if( !( facet.Value is TermFacet ) ) continue; var f = facet.Value as TermFacet; foreach( var value in f.Items ) { result.AddFacetField( facet.Key, value.Term, value.Count ); } } return result; }
public questStatus List(QueryOptions queryOptions, out List <Quest.Functional.MasterPricing.FilterProcedureParameter> filterProcedureParameterList, out QueryResponse queryResponse) { // Initialize questStatus status = null; filterProcedureParameterList = null; queryResponse = null; using (MasterPricingEntities dbContext = new MasterPricingEntities()) { using (DbContextTransaction tx = dbContext.Database.BeginTransaction(IsolationLevel.ReadUncommitted)) { try { PropertyInfo[] dbProperties = typeof(Quest.Services.Dbio.MasterPricing.FilterProcedureParameters).GetProperties().ToArray(); int totalRecords = dbContext.FilterProcedureParameters.Where(BuildWhereClause(queryOptions, dbProperties)).Count(); List <Quest.Services.Dbio.MasterPricing.FilterProcedureParameters> _countriesList = dbContext.FilterProcedureParameters.Where(BuildWhereClause(queryOptions, dbProperties)) .OrderBy(BuildSortString(queryOptions.SortColumns)) .Skip(queryOptions.Paging.PageSize * (queryOptions.Paging.PageNumber - 1)) .Take(queryOptions.Paging.PageSize).ToList(); if (_countriesList == null) { return(new questStatus(Severity.Warning)); } filterProcedureParameterList = new List <Quest.Functional.MasterPricing.FilterProcedureParameter>(); foreach (Quest.Services.Dbio.MasterPricing.FilterProcedureParameters _filterProcedureParameters in _countriesList) { Quest.Functional.MasterPricing.FilterProcedureParameter filterProcedureParameter = new Quest.Functional.MasterPricing.FilterProcedureParameter(); BufferMgr.TransferBuffer(_filterProcedureParameters, filterProcedureParameter); filterProcedureParameterList.Add(filterProcedureParameter); } status = BuildQueryResponse(totalRecords, queryOptions, out queryResponse); if (!questStatusDef.IsSuccess(status)) { return(status); } } catch (System.Exception ex) { return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}", this.GetType().Name, MethodBase.GetCurrentMethod().Name, ex.InnerException != null ? ex.InnerException.Message : ex.Message))); } } } return(new questStatus(Severity.Success)); }
// Pega todos os quartos public QueryResponse <CheckOut> GetAll() { QueryResponse <CheckOut> response = checkOutDAL.GetAll(); return(response); }
public async Task <ActionResult <QueryResponse <Instance> > > GetInstances( [FromQuery] string org, [FromQuery] string appId, [FromQuery(Name = "process.currentTask")] string currentTaskId, [FromQuery(Name = "process.isComplete")] bool?processIsComplete, [FromQuery(Name = "process.endEvent")] string processEndEvent, [FromQuery(Name = "process.ended")] string processEnded, [FromQuery(Name = "instanceOwner.partyId")] int?instanceOwnerPartyId, [FromQuery] string lastChanged, [FromQuery] string created, [FromQuery(Name = "visibleAfter")] string visibleAfter, [FromQuery] string dueBefore, [FromQuery] string excludeConfirmedBy, [FromQuery(Name = "status.isSoftDeleted")] bool isSoftDeleted, [FromQuery(Name = "status.isArchived")] bool isArchived, string continuationToken, int?size) { int pageSize = size ?? 100; string selfContinuationToken = null; bool isOrgQuerying = false; // if user is org string orgClaim = User.GetOrg(); int? userId = User.GetUserIdAsInt(); if (orgClaim != null) { isOrgQuerying = true; if (!_authzHelper.ContainsRequiredScope(_instanceReadScope, User)) { return(Forbid()); } if (string.IsNullOrEmpty(org) && string.IsNullOrEmpty(appId)) { return(BadRequest("Org or AppId must be defined.")); } org = string.IsNullOrEmpty(org) ? appId.Split('/')[0] : org; if (!orgClaim.Equals(org, StringComparison.InvariantCultureIgnoreCase)) { return(Forbid()); } } else if (userId != null) { if (instanceOwnerPartyId == null) { return(BadRequest("InstanceOwnerPartyId must be defined.")); } } else { return(BadRequest()); } if (!string.IsNullOrEmpty(continuationToken)) { selfContinuationToken = continuationToken; continuationToken = HttpUtility.UrlDecode(continuationToken); } Dictionary <string, StringValues> queryParams = QueryHelpers.ParseQuery(Request.QueryString.Value); string host = $"https://platform.{_generalSettings.Hostname}"; string url = Request.Path; string query = Request.QueryString.Value; try { InstanceQueryResponse result = await _instanceRepository.GetInstancesFromQuery(queryParams, continuationToken, pageSize); if (!string.IsNullOrEmpty(result.Exception)) { return(BadRequest(result.Exception)); } if (!isOrgQuerying) { result.Instances = await _authzHelper.AuthorizeInstances(User, result.Instances); result.Count = result.Instances.Count; } string nextContinuationToken = HttpUtility.UrlEncode(result.ContinuationToken); result.ContinuationToken = null; QueryResponse <Instance> response = new QueryResponse <Instance> { Instances = result.Instances, Count = result.Instances.Count, }; if (continuationToken == null) { string selfUrl = $"{host}{url}{query}"; response.Self = selfUrl; } else { string selfQueryString = BuildQueryStringWithOneReplacedParameter( queryParams, "continuationToken", selfContinuationToken); string selfUrl = $"{host}{url}{selfQueryString}"; response.Self = selfUrl; } if (!string.IsNullOrEmpty(nextContinuationToken)) { string nextQueryString = BuildQueryStringWithOneReplacedParameter( queryParams, "continuationToken", nextContinuationToken); string nextUrl = $"{host}{url}{nextQueryString}"; response.Next = nextUrl; } // add self links to platform result.Instances.ForEach(i => i.SetPlatformSelfLinks(_storageBaseAndHost)); return(Ok(response)); } catch (Exception e) { _logger.LogError($"Unable to perform query on instances due to: {e}"); return(StatusCode(500, $"Unable to perform query on instances due to: {e.Message}")); } }
protected IQueryResponse[] CoreExecuteQuery(IQuery context, string text, IEnumerable <QueryParameter> parameters) { // Where Query result eventually resides. int resultId = -1; // For each StreamableObject in the query object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. // Evaluate the sql Query. var query = new SqlQuery(text); if (parameters != null) { foreach (var p in parameters) { var c = p.SqlType.TypeCode; switch (c) { case SqlTypeCode.Blob: case SqlTypeCode.Clob: case SqlTypeCode.LongVarBinary: case SqlTypeCode.LongVarChar: case SqlTypeCode.VarBinary: case SqlTypeCode.VarChar: throw new NotImplementedException("TODO: Download the Large-Objects and replace with a reference"); } } } var stopwatch = new Stopwatch(); stopwatch.Start(); var results = context.ExecuteQuery(query); var responses = new IQueryResponse[results.Length]; int j = 0; foreach (var result in results) { QueryResult queryResult; try { queryResult = new QueryResult(query, result); resultId = AddResult(queryResult); } catch (Exception) { if (resultId != -1) { DisposeResult(resultId); } throw; } var taken = stopwatch.ElapsedMilliseconds; // Return the Query response responses[j] = new QueryResponse(resultId, queryResult, (int)taken, ""); j++; } stopwatch.Stop(); return(responses); }
private void OnQuery(QueryResponse resp, Dictionary <string, object> customData) { Log.Debug("ExampleDiscovery.OnQuery()", "Discovery - Query Response: {0}", customData["json"].ToString()); _queryTested = true; }
public static bool SafeFilter(this FilterQuery filter, IGameObject obj, string mnemoCode, QueryResponse response, params object[] args) { return filter == null || filter(obj, mnemoCode, response, args); }
public QueryResponse <SpaceTraining> GetAllList() { QueryResponse <SpaceTraining> response = spaceDAL.GetAllList(); return(response); }
public void TestQueryResponse() { var responseXml = new XmlDocument(); responseXml.LoadXml(@"<?xml version='1.0' encoding='UTF-8'?> <response> <transaction id=""599086""> <customerrefno>19aa8f62d9cb44eb6851ff3650873b2ac</customerrefno> <merchantid>1130</merchantid> <status>SUCCESS</status> <amount>25000</amount> <currency>SEK</currency> <vat>5000</vat> <capturedamount>25000</capturedamount> <authorizedamount>25000</authorizedamount> <created>2015-04-23 10:51:06.977</created> <creditstatus>CREDNONE</creditstatus> <creditedamount>0</creditedamount> <merchantresponsecode>0</merchantresponsecode> <paymentmethod>DBNORDEASE</paymentmethod> <callbackurl>https://hej.hopp</callbackurl> <subscriptionid>subid</subscriptionid> <subscriptiontype>subtype</subscriptiontype> <capturedate>2015-04-23 10:51:06.977</capturedate> <eci>eci</eci> <mdstatus>mdstatus</mdstatus> <expiryyear>2015</expiryyear> <expirymonth>09</expirymonth> <ch_name>ch_name</ch_name> <authcode>authcode</authcode> <customer id=""22513""> <firstname>Testa</firstname> <lastname>Testson</lastname> <initials>TT</initials> <fullname>Testa T Testson</fullname> <email>[email protected]</email> <ssn>460509-2222</ssn> <address>Testgatan 666</address> <address2>c/o Quality Man</address2> <city>Testholm</city> <country>SE</country> <zip>123 45</zip> <phone>012345566789</phone> <vatnumber>123456-7890</vatnumber> <housenumber>69</housenumber> <companyname>TestCompagniet</companyname> </customer> <orderrows> <row> <id>72750</id> <name>Prod</name> <amount>12500</amount> <vat>2500</vat> <description>Specification</description> <quantity>2.0</quantity> <sku>1</sku> <unit>st</unit> </row> </orderrows> </transaction> <statuscode>0</statuscode> </response>"); QueryResponse response = Query.Response(responseXml); Assert.That(response.TransactionId, Is.EqualTo(599086)); Assert.That(response.CustomerRefNo, Is.EqualTo("19aa8f62d9cb44eb6851ff3650873b2ac")); Assert.That(response.ClientOrderNumber, Is.EqualTo("19aa8f62d9cb44eb6851ff3650873b2ac")); Assert.That(response.Transaction.CustomerRefNo, Is.EqualTo("19aa8f62d9cb44eb6851ff3650873b2ac")); Assert.That(response.Transaction.ClientOrderNumber, Is.EqualTo("19aa8f62d9cb44eb6851ff3650873b2ac")); Assert.That(response.Transaction.MerchantId, Is.EqualTo(1130)); Assert.That(response.Transaction.Status, Is.EqualTo("SUCCESS")); Assert.That(response.Transaction.Amount, Is.EqualTo(250.00M)); Assert.That(response.Transaction.Currency, Is.EqualTo("SEK")); Assert.That(response.Transaction.Vat, Is.EqualTo(50.00M)); Assert.That(response.Transaction.CapturedAmount, Is.EqualTo(250.00M)); Assert.That(response.Transaction.AuthorizedAmount, Is.EqualTo(250.00M)); Assert.That(response.Transaction.Created, Is.EqualTo(new DateTime(2015, 04, 23, 10, 51, 06, 977))); Assert.That(response.Transaction.CreditStatus, Is.EqualTo("CREDNONE")); Assert.That(response.Transaction.CreditedAmount, Is.EqualTo(0.00M)); Assert.That(response.Transaction.MerchantResponseCode, Is.EqualTo(0)); Assert.That(response.Transaction.PaymentMethod, Is.EqualTo("DBNORDEASE")); Assert.That(response.Transaction.CallbackUrl, Is.EqualTo("https://hej.hopp")); Assert.That(response.Transaction.SubscriptionId, Is.EqualTo("subid")); Assert.That(response.Transaction.SubscriptionType, Is.EqualTo("subtype")); Assert.That(response.Transaction.Eci, Is.EqualTo("eci")); Assert.That(response.Transaction.MdStatus, Is.EqualTo("mdstatus")); Assert.That(response.Transaction.ExpiryYear, Is.EqualTo("2015")); Assert.That(response.Transaction.ExpiryMonth, Is.EqualTo("09")); Assert.That(response.Transaction.ChName, Is.EqualTo("ch_name")); Assert.That(response.Transaction.AuthCode, Is.EqualTo("authcode")); Assert.That(response.Transaction.Customer.Id, Is.EqualTo("22513")); Assert.That(response.Transaction.Customer.FirstName, Is.EqualTo("Testa")); Assert.That(response.Transaction.Customer.LastName, Is.EqualTo("Testson")); Assert.That(response.Transaction.Customer.Initials, Is.EqualTo("TT")); Assert.That(response.Transaction.Customer.FullName, Is.EqualTo("Testa T Testson")); Assert.That(response.Transaction.Customer.Email, Is.EqualTo("*****@*****.**")); Assert.That(response.Transaction.Customer.Ssn, Is.EqualTo("460509-2222")); Assert.That(response.Transaction.Customer.Address, Is.EqualTo("Testgatan 666")); Assert.That(response.Transaction.Customer.Address2, Is.EqualTo("c/o Quality Man")); Assert.That(response.Transaction.Customer.City, Is.EqualTo("Testholm")); Assert.That(response.Transaction.Customer.Country, Is.EqualTo("SE")); Assert.That(response.Transaction.Customer.Zip, Is.EqualTo("123 45")); Assert.That(response.Transaction.Customer.Phone, Is.EqualTo("012345566789")); Assert.That(response.Transaction.Customer.VatNumber, Is.EqualTo("123456-7890")); Assert.That(response.Transaction.Customer.HouseNumber, Is.EqualTo("69")); Assert.That(response.Transaction.Customer.CompanyName, Is.EqualTo("TestCompagniet")); Assert.That(response.Transaction.OrderRows[0].Id, Is.EqualTo("72750")); Assert.That(response.Transaction.OrderRows[0].Name, Is.EqualTo("Prod")); Assert.That(response.Transaction.OrderRows[0].Amount, Is.EqualTo(125.00M)); Assert.That(response.Transaction.OrderRows[0].Vat, Is.EqualTo(25.00M)); Assert.That(response.Transaction.OrderRows[0].Description, Is.EqualTo("Specification")); Assert.That(response.Transaction.OrderRows[0].Quantity, Is.EqualTo(2)); Assert.That(response.Transaction.OrderRows[0].Sku, Is.EqualTo("1")); Assert.That(response.Transaction.OrderRows[0].Unit, Is.EqualTo("st")); Assert.That(response.StatusCode, Is.EqualTo(0)); Assert.That(response.Accepted, Is.True); Assert.That(response.ErrorMessage, Is.Empty); Assert.That(response.Transaction.NumberedOrderRows[0].GetName(), Is.EqualTo("Prod")); Assert.That(response.Transaction.NumberedOrderRows[0].GetAmountExVat(), Is.EqualTo(100.00M)); Assert.That(response.Transaction.NumberedOrderRows[0].GetAmountIncVat(), Is.EqualTo(125.00M)); Assert.That(response.Transaction.NumberedOrderRows[0].GetVatPercent(), Is.EqualTo(25.00M)); Assert.That(response.Transaction.NumberedOrderRows[0].GetDescription(), Is.EqualTo("Specification")); Assert.That(response.Transaction.NumberedOrderRows[0].GetQuantity(), Is.EqualTo(2)); Assert.That(response.Transaction.NumberedOrderRows[0].GetArticleNumber(), Is.EqualTo("1")); Assert.That(response.Transaction.NumberedOrderRows[0].GetUnit(), Is.EqualTo("st")); }
public static dynamic ManageRelationWithProject(dynamic data, RecordManager recMan, string itemType) { var relation = (EntityRelation)data.relation; var attachTargetRecords = (List <EntityRecord>)data.attachTargetRecords; var detachTargetRecords = (List <EntityRecord>)data.detachTargetRecords; var originEntity = (Entity)data.originEntity; var targetEntity = (Entity)data.targetEntity; var newOriginRecord = (EntityRecord)data.originRecord; var newProjectRecord = new EntityRecord(); var attachedRecordForeachObject = new EntityRecord(); var hookedRelationName = "project_1_n_task"; var hookedEntityName = "wv_task"; if (itemType == "bug") { hookedRelationName = "project_1_n_bug"; hookedEntityName = "wv_bug"; } if (relation.Name == hookedRelationName) { #region << Select the project >> { newProjectRecord = new EntityRecord(); EntityQuery query = new EntityQuery("wv_project", "code", EntityQuery.QueryEQ("id", (Guid)newOriginRecord["id"]), null, null, null); QueryResponse result = recMan.Find(query); if (!result.Success || result.Object.Data.Count == 0) { throw new Exception("could not select the new project record"); } newProjectRecord = result.Object.Data.First(); } #endregion foreach (var attachedRecord in attachTargetRecords) { #region << Select the attached >> { attachedRecordForeachObject = new EntityRecord(); EntityQuery query = new EntityQuery(hookedEntityName, "id,number", EntityQuery.QueryEQ("id", (Guid)attachedRecord["id"]), null, null, null); QueryResponse result = recMan.Find(query); if (!result.Success || result.Object.Data.Count == 0) { throw new Exception("could not select the bug record"); } attachedRecordForeachObject = result.Object.Data.First(); } #endregion var patchObject = new EntityRecord(); patchObject["id"] = attachedRecordForeachObject["id"]; patchObject["code"] = newProjectRecord["code"] + "-T" + attachedRecordForeachObject["number"]; if (itemType == "bug") { patchObject["code"] = newProjectRecord["code"] + "-B" + attachedRecordForeachObject["number"]; } using (SecurityContext.OpenSystemScope()) { var patchResult = recMan.UpdateRecord(hookedEntityName, patchObject); if (!patchResult.Success) { //nothing for now } } } } return(data); }
public questStatus List(QueryOptions queryOptions, out List <FilterValue> filterValueList, out QueryResponse queryResponse) { // Initialize questStatus status = null; filterValueList = null; // List status = _dbFilterValuesMgr.List(queryOptions, out filterValueList, out queryResponse); if (!questStatusDef.IsSuccess(status)) { return(status); } return(new questStatus(Severity.Success)); }
public QueryResponse QueryWithFullResponse(string method, string function, Dictionary <string, string> param = null, bool auth = false, bool json = false) { QueryResponse resp = new QueryResponse(); string paramData = json ? BuildJSON(param) : BuildQueryData(param); string url = "/api/v1" + function + ((method == "GET" && paramData != "") ? "?" + paramData : ""); string postData = (method != "GET") ? paramData : ""; HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(domain + url); webRequest.Method = method; if (auth) { string expires = GetExpires().ToString(); string message = method + url + expires + postData; byte[] signatureBytes = hmacsha256(Encoding.UTF8.GetBytes(apiSecret), Encoding.UTF8.GetBytes(message)); string signatureString = ByteArrayToString(signatureBytes); webRequest.Headers.Add("api-expires", expires); webRequest.Headers.Add("api-key", apiKey); webRequest.Headers.Add("api-signature", signatureString); } try { if (postData != "") { webRequest.ContentType = json ? "application/json" : "application/x-www-form-urlencoded"; var data = Encoding.UTF8.GetBytes(postData); using (var stream = webRequest.GetRequestStream()) { stream.Write(data, 0, data.Length); } } using (WebResponse webResponse = webRequest.GetResponse()) using (Stream str = webResponse.GetResponseStream()) using (StreamReader sr = new StreamReader(str)) { resp.Response = sr.ReadToEnd(); foreach (string key in webResponse.Headers.AllKeys) { resp.Headers.Add(key, webResponse.Headers[key]); } } } catch (WebException wex) { using (HttpWebResponse response = (HttpWebResponse)wex.Response) { if (response == null) { throw; } using (Stream str = response.GetResponseStream()) { using (StreamReader sr = new StreamReader(str)) { resp.Response = sr.ReadToEnd(); foreach (string key in response.Headers.AllKeys) { resp.Headers.Add(key, response.Headers[key]); } } } } } return(resp); }
private void ProcessDeviceStateQueryRequest(QueryRequestType requestType, QueryRequest alexaRequest, QueryResponse response) { IPremiseObject applianceToQuery; InformLastContact("QueryRequest:" + alexaRequest.payload.appliance.additionalApplianceDetails.path).GetAwaiter().GetResult(); try { // Find the object Guid premiseId = new Guid(alexaRequest.payload.appliance.applianceId); applianceToQuery = PremiseServer.RootObject.GetObject(premiseId.ToString("B")).GetAwaiter().GetResult(); if (applianceToQuery == null) { throw new Exception(); } switch (requestType) { /* * case QueryRequestType.PowerState: * string state = applianceToQuery.GetValue("PowerState").GetAwaiter().GetResult(); * break; * * case QueryRequestType.DimmerLevel: * string state = applianceToQuery.GetValue("Brightness").GetAwaiter().GetResult(); * break; * * case QueryRequestType.ColorTemperature: * string state = applianceToQuery.GetValue("ColorTemperature").GetAwaiter().GetResult(); * break; * * case QueryRequestType.Color: * string state = applianceToQuery.GetValue("Hue").GetAwaiter().GetResult(); * break; */ case QueryRequestType.RetrieveCameraStreamUri: { response.payload.uri = new ApplianceValue(); string host = applianceToQuery.GetValue <string>("Host").GetAwaiter().GetResult(); string port = applianceToQuery.GetValue <string>("Port").GetAwaiter().GetResult(); string path = applianceToQuery.GetValue <string>("Path").GetAwaiter().GetResult(); response.payload.uri.value = string.Format(@"rtsp://{0}:{1}{2}", host, port, path); } break; case QueryRequestType.GetTargetTemperature: Temperature coolingSetPoint = new Temperature(applianceToQuery.GetValue <double>("CoolingSetPoint").GetAwaiter().GetResult()); Temperature heatingSetPoint = new Temperature(applianceToQuery.GetValue <double>("HeatingSetPoint").GetAwaiter().GetResult()); int temperatureMode = applianceToQuery.GetValue <int>("TemperatureMode").GetAwaiter().GetResult(); response.payload.temperatureMode = new ApplianceTemperatureMode { value = TemperatureMode.ModeToString(temperatureMode) }; response.payload.heatingTargetTemperature = new ApplianceTemperatureReading { value = double.Parse(string.Format("{0:N2}", heatingSetPoint.Celcius)), scale = "CELSIUS" }; response.payload.coolingTargetTemperature = new ApplianceTemperatureReading { value = double.Parse(string.Format("{0:N2}", coolingSetPoint.Celcius)), scale = "CELSIUS" }; //response.payload.applianceResponseTimestamp = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.ffZ");// XmlConvert.ToString(DateTime.UtcNow.ToUniversalTime(), XmlDateTimeSerializationMode.Utc); break; case QueryRequestType.GetTemperatureReading: Temperature temperature = new Temperature(applianceToQuery.GetValue <double>("Temperature").GetAwaiter().GetResult()); response.payload.temperatureReading = new ApplianceTemperatureReading { value = double.Parse(string.Format("{0:N2}", temperature.Celcius)), scale = "CELSIUS" }; //response.payload.applianceResponseTimestamp = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.ffZ"); //XmlConvert.ToString(DateTime.UtcNow.ToUniversalTime(), XmlDateTimeSerializationMode.Utc); break; default: response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.UnsupportedOperationError; response.payload.exception = new ExceptionResponsePayload { errorInfo = new ErrorInfo { description = "Unsupported Query Request Type" } }; break; } } catch { response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.NoSuchTargetError; response.payload.exception = new ExceptionResponsePayload(); } }
public questStatus List(QueryOptions queryOptions, out List <TypeList> typeListList, out QueryResponse queryResponse) { // Initialize questStatus status = null; typeListList = null; // List usStates status = _dbTypeListsMgr.List(queryOptions, out typeListList, out queryResponse); if (!questStatusDef.IsSuccess(status)) { return(status); } return(new questStatus(Severity.Success)); }
private void OnQueryMapCompleted(object sender, Service.QueryMapCompletedEventArgs e) { if (e != null && e.Result != null) { e.Result.DecompressResponse(); } NodesEventArgs eventArgs = new NodesEventArgs(); QueryResponse soapServiceQueryResponse = e.Result; QueryMapResponseStateInfo callerInfo = e.UserState as QueryMapResponseStateInfo; if (soapServiceQueryResponse.FinalObjectIndex <= 0) { ServerObjects.QueryResponse soQueryResponse = ServerObjectConverter.ToQueryResponse(soapServiceQueryResponse); Graph.NodesAndRelationshipBuildEventArgs(eventArgs, soQueryResponse.Nodes, soQueryResponse.Relationships); if (e.Result.NodeContext != null) { INode context = eventArgs.Nodes[e.Result.NodeContext.N]; if (callerInfo.ResponseType == QueryMapResponseStateType.ById) { QueryMapByIdCompleted.FireEvent(context.Id, this, eventArgs); } else if (callerInfo.ResponseType == QueryMapResponseStateType.ByNode) { QueryMapByNodeCompleted.FireEvent(context, this, eventArgs); } } else { /// TODO: Need to find a nicer way of handling this exception rather than just ignoring it altogether. //throw new NodeNotFoundException("The given node wasn't found"); } } else { QueryResponse aggregatedResponse = new QueryResponse(); aggregatedResponse.Domain = soapServiceQueryResponse.Domain; aggregatedResponse.NodeContext = soapServiceQueryResponse.NodeContext; aggregatedResponse.Nodes = new Dictionary<Guid, Service.NO>(); aggregatedResponse.Relationships = new Dictionary<Guid, Service.RE>(); foreach (KeyValuePair<Guid, Service.NO> nodePair in soapServiceQueryResponse.Nodes) { aggregatedResponse.Nodes[nodePair.Key] = nodePair.Value; } foreach (KeyValuePair<Guid, Service.RE> relationshipPair in soapServiceQueryResponse.Relationships) { aggregatedResponse.Relationships[relationshipPair.Key] = relationshipPair.Value; } //ServiceProxy.QueryMapPagedCompleted += OnQueryMapByIdPagedCompleted; QueryMapResponseStateInfo info = new QueryMapResponseStateInfo(); info.AggregatedResponse = aggregatedResponse; info.ResponseType = callerInfo.ResponseType; ServiceProxy.QueryMapPagedAsync(CallingUrl.Url, aggregatedResponse.Domain.DomainUid, aggregatedResponse.NodeContext.N, 1, null, null, soapServiceQueryResponse.LastObjectIndex + 1, info); } }
public QueryResponse <SpaceTraining> GetSpaceWithEmptySeat(int personsPerRoom) { QueryResponse <SpaceTraining> response = spaceDAL.GetSpaceWithEmptySeat(personsPerRoom); return(response); }
public static QueryResponse Deserialize(XmlReader reader, QueryResponse queryResponse ) { if (reader.IsStartElement( DTD.Response.TagQueryResponse)) { if (!reader.IsEmptyElement) { reader.ReadStartElement(); #region <ERROR> if (reader.IsStartElement(DTD.Response.ServiceResponse.TagError)) { throw XMLErrorSerializer.Deserialize(reader.ReadSubtree()); } #endregion <ERROR> if (queryResponse == null) { queryResponse = new QueryResponse(); } bool lIsHeadProcessed = false; Dictionary<string,DataColumn> lHeadOid = null; Dictionary<string, DataColumn> lHeadCol = null; List<string> lDisplayset = null; List<int> lDuplicates = null; do { #region <Head>. if (reader.IsStartElement(DTD.Response.QueryResponse.TagHead)) { string lClassName = string.Empty; XmlHead.Deserialize(reader.ReadSubtree(), out lHeadOid, out lHeadCol, out lDisplayset, out lDuplicates, ref lClassName); queryResponse.ClassName = lClassName; lIsHeadProcessed = true; } #endregion <Head>. else { #region <Data>. if (reader.IsStartElement(DTD.Response.QueryResponse.TagData)) { if (lIsHeadProcessed) { queryResponse.Data = XmlData.Deserialize(reader.ReadSubtree(), lHeadOid, lHeadCol, lDuplicates, queryResponse.ClassName); if(queryResponse.Data != null) { queryResponse.Data.ExtendedProperties.Add(DataTableProperties.DisplaySetNames, lDisplayset); } } else { throw new ArgumentOutOfRangeException("Node Data from Query.Response is processed before Head node in Xml"); } } #endregion <Data>. else { #region <?> reader.Skip(); if (reader.NodeType == XmlNodeType.None) { break; } else { continue; } #endregion <?> } } } while (reader.Read()); } else { reader.Skip(); } } else { throw new ArgumentException(); } return queryResponse; }
public SingleResponse <Operator> CheckHowToCreate(SpaceTraining _space) { SingleResponse <Operator> response = new SingleResponse <Operator>(); Operator op = new Operator(); Response responseValidate = Validate(_space); if (responseValidate.Success) { //o usuário irá informar a menor sala que ele tem disponível PersonBLL personBLL = new PersonBLL(); QueryResponse <Person> r0 = personBLL.GetAllList(); int totalPersons = r0.Data.Count; int personsPerRoom = _space.MaxCapacity; int remains = totalPersons % personsPerRoom; int division = totalPersons / personsPerRoom; int totalSpaces; int totalSpaceFull; //se o remains (resto) for igual a zero, significa que podemos distribuir as pessoas nas salas em quantidades iguais e o total de salas será o divisor op.IsAllFull = false; if (remains == 0) { totalSpaces = division; op.IsAllFull = true; } else //caso contrário, acrescentamos +1 sala para todos serem alocados { totalSpaces = division + 1; } //preciso saber a quantidade total de salas cheias //a menor sala será a quantidade máxima que poderá ter em cada sala, existirão salas cheias e salas não cheias em que colocarei personsPerRoom -1, pois assim a diferença de pessoas entre as salas será de no máximo 1 //e também tem outra questão, o usuário cadastrou a menor sala, ok, mas isso não significa que todas as outras terão capacidade a mais, então é melhor que a lotação máxima da menor sala seja também o máximo de pessoas que serão alocadas //a formula abaixo irá me ceder quantas salas cheias existirão //total de pessoas: 40 //totalSpaces = 40 / 6 (o divisor é 6, então o totalSpaces é 6 + 1 = 7) //t = 40 + (1 - 6) * 7 //t = 40 + 7 - 42 //t = 5 (o total de salas cheias será igual a 5, então 5 salas terão capacidade 6 e 2 salas terão capacidade 5 //ou seja, lugar para 40 pessoas conforme pedi //em algumas contas, o total de lugares fica acima do total de pessoas, mas não importa, haverá lugares para todo mundo respeitando regras do desafio totalSpaceFull = totalPersons + (1 - personsPerRoom) * totalSpaces; if (totalSpaceFull > 0) { //se cair aqui, apresentamos total de salas cheias e não cheias com respectivas capacidades if (totalSpaceFull < 0) { op.TotalSpaceFull = totalSpaceFull + (-totalSpaceFull * 2); } else { op.TotalSpaceFull = totalSpaceFull; } op.PersonsPerFullRoom = personsPerRoom; op.PersonsPerNotFullRoom = personsPerRoom - 1; op.TotalSpaceNotFull = totalSpaces - op.TotalSpaceFull; response.Data = op; SingleResponse <SpaceTraining> r1 = this.Get(_space); r1.Data.MaxCapacity = op.PersonsPerFullRoom; this.UpdateMaxCapacity(r1.Data); } else { //se cair aqui, apresentamos total de salas cheias com sua respectiva capacidade if (totalPersons % personsPerRoom != 0) { List <int> x = new List <int>(); //encontrando o número ideal de pessoas por sala, garantindo que o resto da divisão resulte em zero for (int i = 1; i <= personsPerRoom; i++) { if (totalPersons % i == 0) { x.Add(i); } } personsPerRoom = x.Max(); totalSpaces = totalPersons / personsPerRoom; } op.TotalSpaceFull = totalSpaces; op.TotalSpaceNotFull = 0; op.PersonsPerFullRoom = personsPerRoom; op.PersonsPerNotFullRoom = 0; op.IsAllFull = true; response.Data = op; SingleResponse <SpaceTraining> r1 = this.Get(_space); r1.Data.MaxCapacity = op.PersonsPerFullRoom; this.UpdateMaxCapacity(r1.Data); } response.Success = true; return(response); } else { response.Message = responseValidate.Message; response.Success = false; return(response); } }
public QueryResponse Query(QueryRequest alexaRequest) { var response = new QueryResponse(); //IPremiseObject PremiseServer.HomeObject, rootObject; #region CheckRequest if ((alexaRequest == null) || (alexaRequest.header == null) || (alexaRequest.header.payloadVersion != "2")) { response.header.@namespace = Faults.Namespace; response.header.name = Faults.UnexpectedInformationReceivedError; response.payload.exception = new ExceptionResponsePayload { faultingParameter = "alexaRequest" }; return(response); } #endregion CheckRequest #region Initialize Response try { response.header.messageId = alexaRequest.header.messageId; response.header.@namespace = alexaRequest.header.@namespace; response.header.name = alexaRequest.header.name.Replace("Request", "Response"); //alexaRequest.header.name + "Response"; } catch (Exception) { response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.UnexpectedInformationReceivedError; response.payload.exception = new ExceptionResponsePayload { faultingParameter = "alexaRequest.header.name" }; return(response); } #endregion Initialize Response //SYSClient client = new SYSClient(); #region ConnectToPremise if (PremiseServer.HomeObject == null) { response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.DependentServiceUnavailableError; response.payload.exception = new ExceptionResponsePayload { dependentServiceName = "Premise Server" }; return(response); } #endregion ConnectToPremise #region Dispatch Query try { if (!CheckAccessToken(alexaRequest.payload.accessToken).GetAwaiter().GetResult()) { response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.InvalidAccessTokenError; response.payload.exception = new ExceptionResponsePayload(); return(response); } string command = alexaRequest.header.name.Trim().ToUpper(); switch (command) { case "RETRIEVECAMERASTREAMURIREQUEST": ProcessDeviceStateQueryRequest(QueryRequestType.RetrieveCameraStreamUri, alexaRequest, response); break; case "GETTARGETTEMPERATUREREQUEST": ProcessDeviceStateQueryRequest(QueryRequestType.GetTargetTemperature, alexaRequest, response); break; case "GETTEMPERATUREREADINGREQUEST": ProcessDeviceStateQueryRequest(QueryRequestType.GetTemperatureReading, alexaRequest, response); break; default: response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.UnsupportedOperationError; response.payload.exception = new ExceptionResponsePayload { errorInfo = new ErrorInfo { description = "Unsupported Query Request Type" } }; break; } } catch (Exception e) { response.header.@namespace = Faults.QueryNamespace; response.header.name = Faults.DriverpublicError; response.payload.exception = new ExceptionResponsePayload { errorInfo = new ErrorInfo { description = e.Message } }; } return(response); #endregion Dispatch Query }
public override async Task <ResponseMessage> ReadNextAsync(CancellationToken cancellationToken = default) { CosmosDiagnosticsContext diagnostics = CosmosDiagnosticsContext.Create(this.requestOptions); using (diagnostics.GetOverallScope()) { QueryResponseCore responseCore; try { // This catches exception thrown by the pipeline and converts it to QueryResponse responseCore = await this.cosmosQueryExecutionContext.ExecuteNextAsync(cancellationToken); } catch (OperationCanceledException ex) when(!(ex is CosmosOperationCanceledException)) { throw new CosmosOperationCanceledException(ex, diagnostics); } finally { // This swaps the diagnostics in the context. This shows all the page reads between the previous ReadNextAsync and the current ReadNextAsync diagnostics.AddDiagnosticsInternal(this.cosmosQueryContext.GetAndResetDiagnostics()); } if (responseCore.IsSuccess) { return(QueryResponse.CreateSuccess( result: responseCore.CosmosElements, count: responseCore.CosmosElements.Count, responseLengthBytes: responseCore.ResponseLengthBytes, diagnostics: diagnostics, serializationOptions: this.cosmosSerializationFormatOptions, responseHeaders: new CosmosQueryResponseMessageHeaders( responseCore.ContinuationToken, responseCore.DisallowContinuationTokenMessage, this.cosmosQueryContext.ResourceTypeEnum, this.cosmosQueryContext.ContainerResourceId) { RequestCharge = responseCore.RequestCharge, ActivityId = responseCore.ActivityId, SubStatusCode = responseCore.SubStatusCode ?? Documents.SubStatusCodes.Unknown })); } if (responseCore.CosmosException != null) { return(responseCore.CosmosException.ToCosmosResponseMessage(null)); } return(QueryResponse.CreateFailure( statusCode: responseCore.StatusCode, cosmosException: responseCore.CosmosException, requestMessage: null, diagnostics: diagnostics, responseHeaders: new CosmosQueryResponseMessageHeaders( responseCore.ContinuationToken, responseCore.DisallowContinuationTokenMessage, this.cosmosQueryContext.ResourceTypeEnum, this.cosmosQueryContext.ContainerResourceId) { RequestCharge = responseCore.RequestCharge, ActivityId = responseCore.ActivityId, SubStatusCode = responseCore.SubStatusCode ?? Documents.SubStatusCodes.Unknown, })); } }
private void OnQuery(QueryResponse resp, string data) { Log.Debug("ExampleDiscoveryV1", "Discovery - Query Response: {0}", data); _queryTested = true; }
public QueryResponse UpdateRecord(Entity entity, EntityRecord record) { QueryResponse response = new QueryResponse(); response.Object = null; response.Success = true; response.Timestamp = DateTime.UtcNow; try { if (entity == null) { response.Errors.Add(new ErrorModel { Message = "Invalid entity name." }); } if (record == null) { response.Errors.Add(new ErrorModel { Message = "Invalid record. Cannot be null." }); } else if (!record.Properties.ContainsKey("id")) { response.Errors.Add(new ErrorModel { Message = "Invalid record. Missing ID field." }); } if (response.Errors.Count > 0) { response.Object = null; response.Success = false; response.Timestamp = DateTime.UtcNow; return(response); } if (!ignoreSecurity) { bool hasPermisstion = SecurityContext.HasEntityPermission(EntityPermission.Update, entity); if (!hasPermisstion) { response.StatusCode = HttpStatusCode.Forbidden; response.Success = false; response.Message = "Trying to update record in entity '" + entity.Name + "' with no update access."; response.Errors.Add(new ErrorModel { Message = "Access denied." }); return(response); } } SetRecordServiceInformation(record, false); List <KeyValuePair <string, object> > storageRecordData = new List <KeyValuePair <string, object> >(); var recordFields = record.GetProperties(); foreach (var field in entity.Fields) { var pair = recordFields.SingleOrDefault(x => x.Key == field.Name); try { if (pair.Key == null) { continue; } if (field is PasswordField && pair.Value == null) { continue; } storageRecordData.Add(new KeyValuePair <string, object>(field.Name, ExtractFieldValue(pair, field, true))); } catch (Exception ex) { if (pair.Key == null) { throw new Exception("Error during processing value for field: '" + field.Name + "'. No value is specified."); } else { throw new Exception("Error during processing value for field: '" + field.Name + "'. Invalid value: '" + pair.Value + "'", ex); } } } var recRepo = DbContext.Current.RecordRepository; recRepo.Update(entity.Name, storageRecordData); //fixes issue with ID comming from webapi request Guid recordId = Guid.Empty; if (record["id"] is string) { recordId = new Guid(record["id"] as string); } else if (record["id"] is Guid) { recordId = (Guid)record["id"]; } else { throw new Exception("Invalid record id"); } var query = EntityQuery.QueryEQ("id", recordId); var entityQuery = new EntityQuery(entity.Name, "*", query); response = Find(entityQuery); if (response.Object != null && response.Object.Data.Count > 0) { response.Message = "Record was updated successfully"; } else { response.Success = false; response.Message = "Record was not updated successfully"; } return(response); } catch (Exception e) { response.Success = false; response.Object = null; response.Timestamp = DateTime.UtcNow; #if DEBUG response.Message = e.Message + e.StackTrace; #else response.Message = "The entity record was not update. An internal error occurred!"; #endif return(response); } }
/// <summary> /// Formats the response status to be sent to th client /// </summary> /// <typeparam name="TQueryResult">The result object type</typeparam> /// <param name="response">the wrapper of the result object</param> /// <returns></returns> protected IActionResult ToResult <TQueryResult>(QueryResponse <TQueryResult> response) => response.MessageType switch {
public QueryResponse DeleteRecord(Entity entity, Guid id) { QueryResponse response = new QueryResponse(); response.Object = null; response.Success = true; response.Timestamp = DateTime.UtcNow; try { if (entity == null) { response.Errors.Add(new ErrorModel { Message = "Invalid entity name." }); response.Success = false; return(response); } if (!ignoreSecurity) { bool hasPermisstion = SecurityContext.HasEntityPermission(EntityPermission.Delete, entity); if (!hasPermisstion) { response.StatusCode = HttpStatusCode.Forbidden; response.Success = false; response.Message = "Trying to delete record in entity '" + entity.Name + "' with no delete access."; response.Errors.Add(new ErrorModel { Message = "Access denied." }); return(response); } } List <KeyValuePair <string, object> > storageRecordData = new List <KeyValuePair <string, object> >(); var query = EntityQuery.QueryEQ("id", id); var entityQuery = new EntityQuery(entity.Name, "*", query); response = Find(entityQuery); if (response.Object != null && response.Object.Data.Count == 1) { DbContext.Current.RecordRepository.Delete(entity.Name, id); } else { response.Success = false; response.Message = "Record was not found."; return(response); } return(response); } catch (Exception e) { response.Success = false; response.Object = null; response.Timestamp = DateTime.UtcNow; #if DEBUG response.Message = e.Message + e.StackTrace; #else response.Message = "The entity record was not update. An internal error occurred!"; #endif return(response); } }
//Extract parts of the SolrNet response and set them in QueryResponse class internal void SetHeader(QueryResponse queryResponse, SolrQueryResults <Movie> solrResults) { queryResponse.QueryTime = solrResults.Header.QTime; queryResponse.Status = solrResults.Header.Status; queryResponse.TotalHits = solrResults.NumFound; }
public QueryResponse Find(EntityQuery query) { QueryResponse response = new QueryResponse { Success = true, Message = "The query was successfully executed.", Timestamp = DateTime.UtcNow }; try { var entity = GetEntity(query.EntityName); if (entity == null) { response.Success = false; response.Message = string.Format("The query is incorrect. Specified entity '{0}' does not exist.", query.EntityName); response.Object = null; response.Errors.Add(new ErrorModel { Message = response.Message }); response.Timestamp = DateTime.UtcNow; return(response); } if (!ignoreSecurity) { bool hasPermisstion = SecurityContext.HasEntityPermission(EntityPermission.Read, entity); if (!hasPermisstion) { response.StatusCode = HttpStatusCode.Forbidden; response.Success = false; response.Message = "Trying to read records from entity '" + entity.Name + "' with no read access."; response.Errors.Add(new ErrorModel { Message = "Access denied." }); return(response); } } try { if (query.Query != null) { ProcessQueryObject(entity, query.Query); } } catch (Exception ex) { response.Success = false; response.Message = "The query is incorrect and cannot be executed."; response.Object = null; response.Errors.Add(new ErrorModel { Message = ex.Message }); response.Timestamp = DateTime.UtcNow; return(response); } var fields = DbContext.Current.RecordRepository.ExtractQueryFieldsMeta(query); var data = DbContext.Current.RecordRepository.Find(query); response.Object = new QueryResult { FieldsMeta = fields, Data = data }; } catch (Exception ex) { response.Success = false; response.Message = "The query is incorrect and cannot be executed"; response.Object = null; response.Errors.Add(new ErrorModel { Message = ex.Message }); response.Timestamp = DateTime.UtcNow; return(response); } return(response); }
internal void GetDeserializedObjectsFromQueryResponseTest(JsonSerializationFormat jsonSerializationFormat) { // Constants to use for vertex document property key/values const string vertex1Id = "v_0"; const string vertex2Id = "v_1"; const string vertex1Label = "l_0"; const string vertex2Label = "l_1"; const string vertex1PkValue = "pk_0"; const string vertex2PkValue = "pk_1"; const string property1Name = "p_0"; const string vertex1Property1Value = "v_0_p_0_v_0"; const string vertex2Property1Value = "v_1_p_0_v_0"; const string property2Name = "p_1"; const double vertex1Property2Value = 12.34; const long vertex2Property2Value = 5678; // Compose two initial vertex documents using eager CosmosElements CosmosObject initialVertex1EagerObject = this.CreateVertexDocument( vertex1Id, vertex1Label, GremlinScenarioTests.PartitionKeyPropertyName, vertex1PkValue, new Tuple <string, IEnumerable <object> >[] { Tuple.Create <string, IEnumerable <object> >(property1Name, new object[] { vertex1Property1Value }), Tuple.Create <string, IEnumerable <object> >(property2Name, new object[] { vertex1Property2Value }), }); CosmosObject initialVertex2EagerObject = this.CreateVertexDocument( vertex2Id, vertex2Label, GremlinScenarioTests.PartitionKeyPropertyName, vertex2PkValue, new Tuple <string, IEnumerable <object> >[] { Tuple.Create <string, IEnumerable <object> >(property1Name, new object[] { vertex2Property1Value }), Tuple.Create <string, IEnumerable <object> >(property2Name, new object[] { vertex2Property2Value }), }); // Serialize the initial vertex object into a document using the specified serialization format IJsonWriter jsonWriter = JsonWriter.Create(jsonSerializationFormat); initialVertex1EagerObject.WriteTo(jsonWriter); ReadOnlyMemory <byte> vertex1JsonWriterResult = jsonWriter.GetResult(); Assert.IsTrue(vertex1JsonWriterResult.Length > 0, "IJsonWriter result data is empty."); jsonWriter = JsonWriter.Create(jsonSerializationFormat); initialVertex2EagerObject.WriteTo(jsonWriter); ReadOnlyMemory <byte> vertex2JsonWriterResult = jsonWriter.GetResult(); Assert.IsTrue(vertex2JsonWriterResult.Length > 0, "IJsonWriter result data is empty."); // Navigate into the serialized vertex documents using lazy CosmosElements CosmosElement vertex1LazyObject = CosmosElement.CreateFromBuffer(vertex1JsonWriterResult); CosmosElement vertex2LazyObject = CosmosElement.CreateFromBuffer(vertex2JsonWriterResult); // Create a dynamically-typed QueryResponse backed by the vertex document CosmosElements CosmosArray vertexArray = CosmosArray.Create( new CosmosElement[] { vertex1LazyObject, vertex2LazyObject, }); QueryResponse queryResponse = QueryResponse.CreateSuccess( vertexArray, count: 2, responseLengthBytes: vertex1JsonWriterResult.Length + vertex2JsonWriterResult.Length, serializationOptions: null, responseHeaders: CosmosQueryResponseMessageHeaders.ConvertToQueryHeaders( sourceHeaders: null, resourceType: ResourceType.Document, containerRid: GremlinScenarioTests.CreateRandomString(10)), diagnostics: new CosmosDiagnosticsContextCore()); QueryResponse <dynamic> cosmosElementQueryResponse = QueryResponse <dynamic> .CreateResponse <dynamic>( queryResponse, MockCosmosUtil.Serializer); // Assert that other objects (anything besides the lazy CosmosElements that we created earlier) are deserialized // from the backing CosmosElement contents rather than being directly returned as CosmosElements List <dynamic> responseCosmosElements = new List <dynamic>(cosmosElementQueryResponse.Resource); Assert.AreEqual(vertexArray.Count, responseCosmosElements.Count); Assert.AreNotSame(vertex1LazyObject, responseCosmosElements[0]); Assert.AreNotSame(vertex2LazyObject, responseCosmosElements[1]); }
public IEnumerable <PostTree> PostTreeByUserId(long id, int startRowIndex, int maximumRows, out QueryResponse response) { return(_postService.GetUserTree(id, startRowIndex, maximumRows, out response)); }
public static QueryResponse <TItem> CreateQueryResponse <TItem>( QueryResponse queryResponse) { return(QueryResponse <TItem> .CreateResponse <TItem>(queryResponse, MockCosmosUtil.Serializer)); }
public IEnumerable <PostTree> PostsByPostReferenceId(long id, int startRowIndex, int maximumRows, out QueryResponse response) { return(_postService.GetPostReferenceTree(id, startRowIndex, maximumRows, out response)); }
public Response( ushort transactionId, ushort flags, QueryResponse queryResponse, OpCode opCode, NsFlags nsFlags, RCode rCode, ushort questions, ushort answerRRs, ushort authorityRRs, string name, NsType nsType, NsClass nsClass, List<Record> additionalRecords, int bytesReceived, Record[] answers, Record[] authoritiveNameServers ) { _bytesReceived = bytesReceived; _answers = answers; _authoritiveNameServers = authoritiveNameServers; _transactionId = transactionId; _flags = flags; _queryResponse = queryResponse; _opCode = opCode; _nsFlags = nsFlags; _rCode = rCode; _questions = questions; _answerRRs = answerRRs; _authorityRRs = authorityRRs; _name = name; _nsType = nsType; _nsClass = nsClass; _additionalRecords = additionalRecords; }
public async Task <IActionResult> GetFoodOfCategory(int id) { QueryResponse <Food> queryFood = await foodService.GetByCategoryId(id); return(Json(queryFood.Data.ToList())); }
public QueryResponse QueryAudience(string audienceId, string groupings) { var qResponse = new QueryResponse(); OAuthResponse response = null; try { response = _manager.GetOAuthResponse("POST", "audience/audiences/" + audienceId + "/query" , groupings); if (response.ErrorFlag) throw response.Error; else qResponse.Text = response.ResponseString; } catch (Exception ex) { qResponse.ErrorFlag = true; qResponse.Error = ex; if (response != null) qResponse.ErrorMessage = response.ResponseString; } return qResponse; }
protected IQueryResponse[] CoreExecuteQuery(string text, IEnumerable <SqlQueryParameter> parameters) { // Record the Query start time DateTime startTime = DateTime.Now; // Where Query result eventually resides. int resultId = -1; // For each StreamableObject in the query object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. // Evaluate the sql Query. var query = new SqlQuery(text); if (parameters != null) { foreach (var parameter in parameters) { var preparedParam = parameter.Value; if (preparedParam is StreamableObject) { var obj = (StreamableObject)preparedParam; IRef objRef = CompleteStream(obj.Identifier); preparedParam = objRef; } query.Parameters.Add(new SqlQueryParameter(parameter.Name, preparedParam)); } } Table[] results = SqlQueryExecutor.Execute(Session.Connection, query); var responses = new IQueryResponse[results.Length]; int j = 0; foreach (Table result in results) { QueryResult queryResult; try { // Put the result in the result cache... This will Lock this object // until it is removed from the result set cache. Returns an id that // uniquely identifies this result set in future communication. // NOTE: This locks the roots of the table so that its contents // may not be altered. queryResult = new QueryResult(query, result); resultId = AddResult(queryResult); } catch (Exception e) { // If resultId set, then dispose the result set. if (resultId != -1) { DisposeResult(resultId); } throw; } // The time it took the Query to execute. TimeSpan taken = DateTime.Now - startTime; // Return the Query response responses[j] = new QueryResponse(resultId, queryResult, (int)taken.TotalMilliseconds, ""); j++; } return(responses); }
/// <inheritdoc/> public virtual IQueryResponse[] ExecuteQuery(SqlQuery query) { CheckNotDisposed(); // Record the Query start time DateTime startTime = DateTime.Now; // Where Query result eventually resides. ResultSetInfo resultSetInfo; int resultId = -1; // For each StreamableObject in the SQLQuery object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. bool blobsWereFlushed = false; object[] vars = query.Variables; if (vars != null) { for (int i = 0; i < vars.Length; ++i) { object ob = vars[i]; // This is a streamable object, so convert it to a *IRef if (ob != null && ob is StreamableObject) { StreamableObject sObject = (StreamableObject) ob; // Flush the streamable object from the cache // Note that this also marks the blob as complete in the blob store. IRef reference = FlushLargeObjectRefFromCache(sObject.Identifier); // Set the IRef object in the Query. vars[i] = reference; // There are blobs in this Query that were written to the blob store. blobsWereFlushed = true; } } } // Evaluate the sql Query. Table[] results = SqlQueryExecutor.Execute(dbConnection, query); IQueryResponse[] responses = new IQueryResponse[results.Length]; int j = 0; foreach (Table result in results) { try { // Put the result in the result cache... This will Lock this object // until it is removed from the result set cache. Returns an id that // uniquely identifies this result set in future communication. // NOTE: This locks the roots of the table so that its contents // may not be altered. resultSetInfo = new ResultSetInfo(query, result); resultId = AddResultSet(resultSetInfo); } catch (Exception e) { // If resultId set, then dispose the result set. if (resultId != -1) DisposeResultSet(resultId); // Handle the throwable during Query execution throw HandleExecuteThrowable(e, query); } // The time it took the Query to execute. TimeSpan taken = DateTime.Now - startTime; // Return the Query response responses[j] = new QueryResponse(resultId, resultSetInfo, (int) taken.TotalMilliseconds, ""); j++; } return responses; }
protected IQueryResponse[] CoreExecuteQuery(IQuery context, string text, IEnumerable<QueryParameter> parameters, QueryParameterStyle parameterStyle) { // Where Query result eventually resides. int resultId = -1; // For each StreamableObject in the query object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. // Evaluate the sql Query. var query = new SqlQuery(text, parameterStyle); if (parameters != null) { foreach (var p in parameters) { var c = p.SqlType.TypeCode; switch (c) { case SqlTypeCode.Blob: case SqlTypeCode.Clob: case SqlTypeCode.LongVarBinary: case SqlTypeCode.LongVarChar: case SqlTypeCode.VarBinary: throw new NotImplementedException("TODO: Download the Large-Objects and replace with a reference"); default: query.Parameters.Add(p); break; } } } var stopwatch = new Stopwatch(); stopwatch.Start(); var results = context.ExecuteQuery(query); var responses = new IQueryResponse[results.Length]; int j = 0; foreach (var result in results) { QueryResult queryResult; try { if (result.Type == StatementResultType.Exception) throw result.Error; queryResult = new QueryResult(query, result, context.AutoCommit()); resultId = AddResult(queryResult); } catch (Exception) { if (resultId != -1) DisposeResult(resultId); throw; } var taken = stopwatch.ElapsedMilliseconds; // Return the Query response responses[j] = new QueryResponse(resultId, queryResult, (int)taken, ""); j++; } stopwatch.Stop(); return responses; }
protected IQueryResponse[] CoreExecuteQuery(IQueryContext context, string text, IEnumerable<QueryParameter> parameters) { // Where Query result eventually resides. int resultId = -1; // For each StreamableObject in the query object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. // Evaluate the sql Query. var query = new SqlQuery(text); if (parameters != null) { // TODO: Download the Large-Objects and replace with a reference } var stopwatch = new Stopwatch(); stopwatch.Start(); var results = context.ExecuteQuery(query); var responses = new IQueryResponse[results.Length]; int j = 0; foreach (var result in results) { QueryResult queryResult; try { queryResult = new QueryResult(query, result); resultId = AddResult(queryResult); } catch (Exception e) { if (resultId != -1) DisposeResult(resultId); throw; } var taken = stopwatch.Elapsed; // Return the Query response responses[j] = new QueryResponse(resultId, queryResult, (int)taken.TotalMilliseconds, ""); j++; } stopwatch.Stop(); return responses; }
} // 0x0000000180246DB0-0x0000000180246DC0 public virtual void OnQuerySuccess(QueryResponse response) { } // 0x0000000180246DB0-0x0000000180246DC0
/// <summary> /// Query Amazon DynamoDB /// </summary> /// <param name="queryRequest"></param> /// <param name="hashKey">Hash key for the query request.</param> /// <param name="range">The range of geohashs to query.</param> /// <returns>The query result.</returns> public async Task <IReadOnlyList <QueryResponse> > QueryGeohashAsync(QueryRequest queryRequest, ulong hashKey, GeohashRange range, CancellationToken cancellationToken = default(CancellationToken)) { if (queryRequest == null) { throw new ArgumentNullException("queryRequest"); } if (range == null) { throw new ArgumentNullException("range"); } var queryResults = new List <QueryResponse>(); IDictionary <String, AttributeValue> lastEvaluatedKey = null; do { var keyConditions = new Dictionary <String, Condition>(); var hashKeyCondition = new Condition { ComparisonOperator = ComparisonOperator.EQ, AttributeValueList = new List <AttributeValue> { new AttributeValue { N = hashKey.ToString(CultureInfo.InvariantCulture) } } }; keyConditions.Add(_config.HashKeyAttributeName, hashKeyCondition); var minRange = new AttributeValue { N = range.RangeMin.ToString(CultureInfo.InvariantCulture) }; var maxRange = new AttributeValue { N = range.RangeMax.ToString(CultureInfo.InvariantCulture) }; var geohashCondition = new Condition { ComparisonOperator = ComparisonOperator.BETWEEN, AttributeValueList = new List <AttributeValue> { minRange, maxRange } }; keyConditions.Add(_config.GeohashAttributeName, geohashCondition); queryRequest.TableName = _config.TableName; queryRequest.KeyConditions = keyConditions; queryRequest.IndexName = _config.GeohashIndexName; queryRequest.ConsistentRead = true; queryRequest.ReturnConsumedCapacity = ReturnConsumedCapacity.TOTAL; if (lastEvaluatedKey != null && lastEvaluatedKey.Count > 0) { queryRequest.ExclusiveStartKey[_config.HashKeyAttributeName] = lastEvaluatedKey[_config.HashKeyAttributeName]; queryRequest.ExclusiveStartKey[_config.RangeKeyAttributeName] = lastEvaluatedKey[_config.RangeKeyAttributeName]; queryRequest.ExclusiveStartKey[_config.GeohashAttributeName] = lastEvaluatedKey[_config.GeohashAttributeName]; } QueryResponse queryResult = await _config.DynamoDBClient.QueryAsync(queryRequest, cancellationToken).ConfigureAwait(false); queryResults.Add(queryResult); lastEvaluatedKey = queryResult.LastEvaluatedKey; } while (lastEvaluatedKey != null && lastEvaluatedKey.Count > 0); return(queryResults); }
protected IQueryResponse[] CoreExecuteQuery(string text, IEnumerable<SqlQueryParameter> parameters) { // Record the Query start time DateTime startTime = DateTime.Now; // Where Query result eventually resides. int resultId = -1; // For each StreamableObject in the query object, translate it to a // IRef object that presumably has been pre-pushed onto the server from // the client. // Evaluate the sql Query. var query = new SqlQuery(text); if (parameters != null) { foreach (var parameter in parameters) { var preparedParam = parameter.Value; if (preparedParam is StreamableObject) { var obj = (StreamableObject) preparedParam; IRef objRef = CompleteStream(obj.Identifier); preparedParam = objRef; } query.Parameters.Add(new SqlQueryParameter(parameter.Name, preparedParam)); } } Table[] results = SqlQueryExecutor.Execute(Session.Connection, query); var responses = new IQueryResponse[results.Length]; int j = 0; foreach (Table result in results) { QueryResult queryResult; try { // Put the result in the result cache... This will Lock this object // until it is removed from the result set cache. Returns an id that // uniquely identifies this result set in future communication. // NOTE: This locks the roots of the table so that its contents // may not be altered. queryResult = new QueryResult(query, result); resultId = AddResult(queryResult); } catch (Exception e) { // If resultId set, then dispose the result set. if (resultId != -1) DisposeResult(resultId); throw; } // The time it took the Query to execute. TimeSpan taken = DateTime.Now - startTime; // Return the Query response responses[j] = new QueryResponse(resultId, queryResult, (int) taken.TotalMilliseconds, ""); j++; } return responses; }