protected Result FormatResult( QueryResponse<ElasticSearchProduct> response )
        {
            var result = new Result
            {
                Products = response.Documents
            };
            this.FormatFacets( response, result );

            return result;
        }
Example #2
0
 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);
 }
Example #3
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");
 }
Example #4
0
 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));
 }
Example #5
0
        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)
        {

        }
Example #6
0
        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));
        }
Example #9
0
        // 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}"));
            }
        }
Example #11
0
        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;
 }
Example #13
0
 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"));
        }
Example #16
0
        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);
        }
Example #17
0
        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));
        }
Example #18
0
        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);
        }
Example #19
0
        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();
            }
        }
Example #20
0
        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));
        }
Example #21
0
        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);
            }
        }
Example #25
0
        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
        }
Example #26
0
        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,
                }));
            }
        }
Example #27
0
 private void OnQuery(QueryResponse resp, string data)
 {
     Log.Debug("ExampleDiscoveryV1", "Discovery - Query Response: {0}", data);
     _queryTested = true;
 }
Example #28
0
        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);
            }
        }
Example #29
0
 /// <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
 {
Example #30
0
        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);
            }
        }
Example #31
0
 //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;
 }
Example #32
0
        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);
        }
Example #33
0
        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]);
        }
Example #34
0
 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));
 }
Example #36
0
 public IEnumerable <PostTree> PostsByPostReferenceId(long id, int startRowIndex, int maximumRows, out QueryResponse response)
 {
     return(_postService.GetPostReferenceTree(id, startRowIndex, maximumRows, out response));
 }
Example #37
0
 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;
 }
Example #38
0
        public async Task <IActionResult> GetFoodOfCategory(int id)
        {
            QueryResponse <Food> queryFood = await foodService.GetByCategoryId(id);

            return(Json(queryFood.Data.ToList()));
        }
Example #39
0
 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);
        }
Example #41
0
        /// <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;
        }
Example #42
0
        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;
        }
Example #43
0
        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;
        }
Example #44
0
            }                                                                          // 0x0000000180246DB0-0x0000000180246DC0

            public virtual void OnQuerySuccess(QueryResponse response)
            {
            }                                                                         // 0x0000000180246DB0-0x0000000180246DC0
Example #45
0
        /// <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);
        }
Example #46
0
        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;
        }