/// <summary>
/// Run the Query
/// </summary>
public void RunQuery()
{
try
{
FormUtil.Busy(this, true);
string query = Query;
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException("query");
}
if (this.qm == null)
{
this.qm = new QueryManager(this.ds);
}
QueryResultSet results = qm.RunBatch(query);
this.DataSource = qm.DataSet;
ShowQueryResult(results);
}
catch (Exception ex)
{
FormUtil.WinException(ex);
}
finally
{
FormUtil.Busy(this, false);
}
}
public async Task <List <int> > WorkspaceQueryAsync(string workspaceName)
{
Console2.WriteDisplayStartLine($"Querying for Workspaces [Name: {workspaceName}]");
try
{
RsapiClient.APIOptions.WorkspaceID = -1;
TextCondition textCondition = new TextCondition(WorkspaceFieldNames.Name, TextConditionEnum.EqualTo, workspaceName);
Query <Workspace> workspaceQuery = new Query <Workspace>
{
Fields = FieldValue.AllFields,
Condition = textCondition
};
QueryResultSet <Workspace> workspaceQueryResultSet = await Task.Run(() => RsapiClient.Repositories.Workspace.Query(workspaceQuery));
if (!workspaceQueryResultSet.Success || workspaceQueryResultSet.Results == null)
{
throw new Exception("Failed to query Workspaces");
}
List <int> workspaceArtifactIds = workspaceQueryResultSet.Results.Select(x => x.Artifact.ArtifactID).ToList();
Console2.WriteDisplayEndLine($"Queried for Workspaces! [Count: {workspaceArtifactIds.Count}]");
return(workspaceArtifactIds);
}
catch (Exception ex)
{
throw new Exception("An error occured when querying Workspaces", ex);
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
MockAgentHelper = null;
MockSqlQueryHelper = null;
MockLogger = null;
MockArtifactQueryHelper = null;
MockLoginManager = null;
MockUserRepo = null;
MockClientRepo = null;
MockGroupRepo = null;
MockRSAPIRepositoryGroup = null;
OffHoursStartTime = null;
OffHoursEndTime = null;
AgentId = 0;
JobArtifactID = 0;
FileName = null;
MockGroupName = null;
MockUserArtifactID = 0;
MockClientName = null;
FileFieldArtifactID = 0;
ResourceGroupIdList = null;
APIOptions = null;
RecordedImportJobErrors = null;
MockChoiceResult = null;
MockClientResult = null;
MockGroupResult = null;
}
}
_disposed = true;
}
public static bool DeleteAllObjectsOfSpecificTypeInWorkspace(IRSAPIClient proxy, int workspaceID, int artifactTypeID)
{
proxy.APIOptions.WorkspaceID = workspaceID;
//Query RDO
WholeNumberCondition condition = new WholeNumberCondition("Artifact ID", NumericConditionEnum.IsSet);
kCura.Relativity.Client.DTOs.Query<RDO> query = new Query<RDO>
{
ArtifactTypeID = artifactTypeID,
Condition = condition
};
QueryResultSet<RDO> results = new QueryResultSet<RDO>();
results = proxy.Repositories.RDO.Query(query);
if (!results.Success)
{
Console.WriteLine("Error deleting the object: " + results.Message);
for (Int32 i = 0; i <= results.Results.Count - 1; i++)
{
if (!results.Results[i].Success)
{
proxy.Repositories.RDO.Delete(results.Results[i].Artifact);
}
}
}
return true;
}
public QueryResultSet <News> QueryTopNewsTitle(int top)
{
string sql = string.Format("SELECT TOP {0} ID,TITLE,POSTTIME FROM NEWS ORDER BY ID DESC ", top);
if (this._conn.State != System.Data.ConnectionState.Open)
{
this._conn.Open();
}
OleDbCommand mycmd = new OleDbCommand(sql, this._conn);
OleDbDataReader mydr = mycmd.ExecuteReader();
List <News> lstNews = new List <News>();
while (mydr.Read())
{
News news = new News();
news.ID = (int)mydr["ID"];
news.TITLE = (string)mydr["TITLE"];
news.POSTTIME = (DateTime)mydr["POSTTIME"];
lstNews.Add(news);
}
this._conn.Close();
QueryResultSet <News> result = new QueryResultSet <News>();
result.TotalCount = top;
result.ResultSet = lstNews;
return(result);
}
/// <summary>
/// Retrieves the next batch of documents from Relativity. Handles QuerySubSet
/// </summary>
/// <param name="workspaceArtifactID"></param>
/// <param name="savedSearchID"></param>
/// <returns></returns>
public QueryResultSet <Document> GetNext(Int32 workspaceArtifactID, Int32 savedSearchID)
{
var query = new Query <Document> {
Condition = new SavedSearchCondition(savedSearchID)
};
query.Fields.Add(new FieldValue("ArtifactID"));
if (IsFirstBatch())
{
resultSet = ArtQueries.GetFirstBatchOfDocuments(
ServicesMgr,
ExecutionIdentity.CurrentUser,
BatchSize,
query,
workspaceArtifactID);
}
else
{
resultSet = ArtQueries.GetSubsequentBatchOfDocuments(
ServicesMgr,
ExecutionIdentity.CurrentUser,
BatchSize,
Index,
CurrentQueryToken,
query,
workspaceArtifactID);
}
Total += resultSet.Results.Count;
Index++;
return(resultSet);
}
public async Task VerifyMessageReturnedWhenMultipleGroupsNotFound()
{
var group1 = "Fake Group";
var group2 = "Fake Group2";
var groupListName = String.Join(Constant.ViolationDelimiter, new List <String> {
group1, group2
});
var mockGroupRepo = new Mock <IGenericRepository <Group> >();
FieldValueList <Group> resultingGroupList;
var groupValidation = new ValidationGroup(new APIOptions(), mockGroupRepo.Object, x => resultingGroupList = x);
var mockResult = new QueryResultSet <Group>
{
Success = true,
Results = new List <Result <Group> >()
};
mockGroupRepo.Setup(x => x.Query(It.IsAny <Query <Group> >(), It.IsAny <Int32>())).Returns(mockResult);
var expectedMessage = String.Format(Constant.Messages.Violations.GroupDoesNotExist, groupListName);
var result = await groupValidation.ValidateAsync(groupListName);
Assert.AreEqual(expectedMessage, result);
}
public async Task VerifyCallbackPopulatesResultingGroup()
{
var groupArtifactID = 1234;
var groupName = "Existing Group";
var mockGroupRepo = new Mock <IGenericRepository <Group> >();
FieldValueList <Group> resultingGroupList = null;
var groupValidation = new ValidationGroup(new APIOptions(), mockGroupRepo.Object, x => resultingGroupList = x);
var mockResult = new QueryResultSet <Group>
{
Success = true,
Results = new List <Result <Group> >
{
new Result <Group>
{
Artifact = new Group(groupArtifactID)
{
Name = groupName
}
}
}
};
mockGroupRepo.Setup(x => x.Query(It.IsAny <Query <Group> >(), It.IsAny <Int32>())).Returns(mockResult);
await groupValidation.ValidateAsync(groupName);
Assert.IsTrue(resultingGroupList != null);
Assert.IsTrue(resultingGroupList.Count == mockResult.Results.Count);
Assert.IsTrue(resultingGroupList[0].ArtifactID == groupArtifactID);
}
/// <summary>
/// Retrieves User info by email
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
private DTOs.User GetUser(string email)
{
DTOs.User user;
Condition userQueryCondition = new TextCondition(UserFieldNames.EmailAddress, TextConditionEnum.EqualTo, email);
Query <DTOs.User> userQuery = new Query <DTOs.User>(FieldValue.AllFields, userQueryCondition, new List <Sort>());
QueryResultSet <DTOs.User> resultSet = null;
using (IRSAPIClient rsapiClient = GetServiceFactory().CreateProxy <IRSAPIClient>())
{
rsapiClient.APIOptions = new APIOptions {
WorkspaceID = -1
};
resultSet = rsapiClient.Repositories.User.Query(userQuery);
if (resultSet.Success && resultSet.TotalCount > 0)
{
user = resultSet.Results.First().Artifact;
}
else
{
throw new Exception($"Could not find user {email}");
}
}
return(user);
}
private static int FindGroupArtifactId(IRSAPIClient rsapiClient, string group)
{
int artifactId = 0;
TextCondition groupCondition = new TextCondition(GroupFieldNames.Name, TextConditionEnum.EqualTo, group);
Query <Group> queryGroup = new Query <Group>
{
Condition = groupCondition
};
queryGroup.Fields.Add(new FieldValue(ArtifactQueryFieldNames.ArtifactID));
try
{
QueryResultSet <Group> resultSetGroup = rsapiClient.Repositories.Group.Query(queryGroup, 0);
if (resultSetGroup.Success && resultSetGroup.Results.Count == 1)
{
artifactId = resultSetGroup.Results.FirstOrDefault().Artifact.ArtifactID;
}
else
{
Console.WriteLine("The Query operation failed.{0}{1}", Environment.NewLine, resultSetGroup.Message);
}
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred: {ex.Message}");
}
return(artifactId);
}
public void BeforeAfterFlowEngineBinder()
{
IInferenceEngine ie = new IEImpl(new FlowEngineBinder(ruleFilesFolder + "testbinder1.ruleml.xbre",
BindingTypes.BeforeAfter));
ie.LoadRuleBase(new RuleML09NafDatalogAdapter(ruleFilesFolder + "testbinder.ruleml",
FileAccess.Read));
ie.NewFactHandler += new NewFactEvent(ShowAllNewFacts);
Hashtable bo = new Hashtable();
bo.Add("THEDUKE", new Character("The Duke", "hello world"));
bo.Add("BOBBYBOB", new Character("Bobby Bob", "what the?"));
bo.Add("JOHNQDOE", new Character("John Q. Doe", "hello, who am i?"));
bo.Add("DANNYDAN", new Character("Danny Dan", "get out of my world"));
ie.Process(bo);
QueryResultSet qrs = ie.RunQuery("all polite");
Assert.AreEqual(2, qrs.Count, "polite Count");
// here, we should have got one result (Danny Dan), but the politness of The Duke has
// mutexed the "mundane" implication.
qrs = ie.RunQuery("all mundane");
Assert.AreEqual(0, qrs.Count, "mundane Count");
}
public async Task VerifyNullReturnWhenGroupExists()
{
var groupName = "Existing Group";
var mockGroupRepo = new Mock <IGenericRepository <Group> >();
FieldValueList <Group> resultingGroupList;
var groupValidation = new ValidationGroup(new APIOptions(), mockGroupRepo.Object, x => resultingGroupList = x);
var mockResult = new QueryResultSet <Group>
{
Success = true,
Results = new List <Result <Group> >
{
new Result <Group>
{
Artifact = new Group()
{
Name = groupName
}
}
}
};
mockGroupRepo.Setup(x => x.Query(It.IsAny <Query <Group> >(), It.IsAny <Int32>())).Returns(mockResult);
var result = await groupValidation.ValidateAsync(groupName);
Assert.AreEqual(null, result);
}
/// <summary>
/// All queries are completed with QuerySubset whether the DTO supports it or not so that
/// this utitlity method can be used with all DTOs
/// </summary>
/// <typeparam name="T"> DTO </typeparam>
/// <param name="repository"> RSASPI Client Repository </param>
/// <param name="query"> Query to Execute </param>
/// <param name="batchSize"> maximum number of items to return in a single call </param>
/// <returns> traditional Query Result Set </returns>
private static QueryResultSet <T> QueryRelativity <T>(IGenericRepository <T> repository, Query <T> query, Int32 batchSize)
where T : kCura.Relativity.Client.DTOs.Artifact, new()
{
var nextStart = 1;
var retValue = new QueryResultSet <T>();
var queryResults = repository.Query(query, batchSize);
CumulateQueryResults(queryResults, retValue);
if (queryResults.Success && queryResults.Results.Count > 0)
{
var queryToken = queryResults.QueryToken;
var batchAvailable = !String.IsNullOrEmpty(queryToken);
while (batchAvailable)
{
nextStart += queryResults.Results.Count;
queryResults = repository.QuerySubset(queryToken, nextStart, batchSize);
CumulateQueryResults(queryResults, retValue);
queryToken = queryResults.QueryToken;
batchAvailable = !String.IsNullOrEmpty(queryToken);
}
}
if (queryResults.Success == false)
{
throw new Exception("Unable to complete Query: " + queryResults.Message);
}
return(retValue);
}
public DocumentBatch(IArtifactQueries artifactQueries, IServicesMgr servicesMgr)
{
ServicesMgr = servicesMgr;
ArtQueries = artifactQueries;
resultSet = new QueryResultSet <Document>();
}
/// <summary>
/// Combines the multiple query result sets into each other.
/// </summary>
/// <typeparam name="T"> DTO type </typeparam>
/// <param name="newAddition"> recent query result </param>
/// <param name="cumulativeResults"> Query results where values will cumulate </param>
private static void CumulateQueryResults <T>(QueryResultSet <T> newAddition, QueryResultSet <T> cumulativeResults)
where T : kCura.Relativity.Client.DTOs.Artifact, new()
{
cumulativeResults.Results.AddRange(newAddition.Results);
cumulativeResults.Success = newAddition.Success;
cumulativeResults.Message += newAddition.Message;
}
public QueryResultSet <Demo> QueryTopDemos(int top)
{
string sql = string.Format("SELECT TOP {0} * FROM APPS ORDER BY ID DESC ", top);
if (this._conn.State != System.Data.ConnectionState.Open)
{
this._conn.Open();
}
OleDbCommand mycmd = new OleDbCommand(sql, this._conn);
OleDbDataReader mydr = mycmd.ExecuteReader();
List <Demo> lstDemos = new List <Demo>();
while (mydr.Read())
{
Demo demo = this.CreateDemoByRecord(mydr);
lstDemos.Add(demo);
}
this._conn.Close();
QueryResultSet <Demo> result = new QueryResultSet <Demo>();
result.TotalCount = top;
result.ResultSet = lstDemos;
return(result);
}
public async Task VerifyCallbackSetsValueOfClient()
{
var clientArtifactID = 1234;
var clientName = "Random Existing Client Name";
Client resultingClient = null;
var mockResult = new QueryResultSet <Client>
{
Success = true,
Results = new List <Result <Client> >
{
new Result <Client>
{
Artifact = new Client(clientArtifactID)
{
Name = clientName
}
}
}
};
var mockClientRepo = new Mock <IGenericRepository <Client> >();
mockClientRepo.Setup(x => x.Query(It.IsAny <Query <Client> >(), It.IsAny <Int32>())).Returns(mockResult);
var clientValidation = new ValidationClient(new APIOptions(), mockClientRepo.Object, x => resultingClient = x);
await clientValidation.ValidateAsync(clientName);
Assert.IsTrue(resultingClient != null);
Assert.IsTrue(resultingClient.ArtifactID == clientArtifactID);
}
public async Task NullReturnedWhenClientPassesValidation()
{
var clientName = "Random Existing Client Name";
Client resultingClient = null;
var mockResult = new QueryResultSet <Client>
{
Success = true,
Results = new List <Result <Client> >
{
new Result <Client>
{
Artifact = new Client()
{
Name = clientName
}
}
}
};
var mockClientRepo = new Mock <IGenericRepository <Client> >();
mockClientRepo.Setup(x => x.Query(It.IsAny <Query <Client> >(), It.IsAny <Int32>())).Returns(mockResult);
var clientValidation = new ValidationClient(new APIOptions(), mockClientRepo.Object, x => resultingClient = x);
var result = await clientValidation.ValidateAsync(clientName);
Assert.AreEqual(null, result);
}
private static int FindChoiceArtifactId(IRSAPIClient rsapiClient, int choiceType, string value)
{
int artifactId = 0;
WholeNumberCondition choiceTypeCondition = new WholeNumberCondition(ChoiceFieldNames.ChoiceTypeID, NumericConditionEnum.EqualTo, (int)choiceType);
TextCondition choiceNameCondition = new TextCondition(ChoiceFieldNames.Name, TextConditionEnum.EqualTo, value);
CompositeCondition choiceCompositeCondition = new CompositeCondition(choiceTypeCondition, CompositeConditionEnum.And, choiceNameCondition);
Query <kCura.Relativity.Client.DTOs.Choice> choiceQuery = new Query <kCura.Relativity.Client.DTOs.Choice>(
new List <FieldValue>
{
new FieldValue(ArtifactQueryFieldNames.ArtifactID)
},
choiceCompositeCondition,
new List <Sort>());
try
{
QueryResultSet <kCura.Relativity.Client.DTOs.Choice> choiceQueryResult = rsapiClient.Repositories.Choice.Query(choiceQuery);
if (choiceQueryResult.Success && choiceQueryResult.Results.Count == 1)
{
artifactId = choiceQueryResult.Results.FirstOrDefault().Artifact.ArtifactID;
}
else
{
Console.WriteLine("The choice could not be found.");
}
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred: {ex.Message}");
}
return(artifactId);
}
private static int FindClientArtifactId(IRSAPIClient rsapiClient, string group)
{
int artifactId = 0;
TextCondition clientCondition = new TextCondition(ClientFieldNames.Name, TextConditionEnum.EqualTo, group);
Query <Client> queryClient = new Query <Client>
{
Condition = clientCondition,
Fields = FieldValue.AllFields
};
try
{
QueryResultSet <Client> resultSetClient = rsapiClient.Repositories.Client.Query(queryClient, 0);
if (resultSetClient.Success && resultSetClient.Results.Count == 1)
{
artifactId = resultSetClient.Results.FirstOrDefault().Artifact.ArtifactID;
}
else
{
Console.WriteLine("The Query operation failed.{0}{1}", Environment.NewLine, resultSetClient.Message);
}
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred: {ex.Message}");
}
return(artifactId);
}
internal void SetResult(QueryContext queryContext, AggregateFunctionType functionType, object result)
{
QueryResultSet resultSet = new QueryResultSet();
resultSet.Type = QueryType.AggregateFunction;
resultSet.AggregateFunctionType = functionType;
resultSet.AggregateFunctionResult = new DictionaryEntry(functionType, result);
queryContext.ResultSet = resultSet;
}
public override void ExecuteCommand(ClientManager clientManager, Alachisoft.NCache.Common.Protobuf.Command command)
{
int overload;
string exception = null;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
try
{
overload = command.MethodOverload;
cmdInfo = ParseCommand(command, clientManager);
}
catch (Exception exc)
{
_serializedResponsePackets.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeExceptionResponse(exc, command.requestID, command.commandID));
return;
}
int resultCount = 0;
try
{
NCache nCache = clientManager.CmdExecuter as NCache;
Alachisoft.NCache.Caching.OperationContext operationContext = new Alachisoft.NCache.Caching.OperationContext(Alachisoft.NCache.Caching.OperationContextFieldName.OperationType, Alachisoft.NCache.Caching.OperationContextOperationType.CacheOperation);
if (cmdInfo.CommandVersion <= 1) //NCache 3.8 SP4 and previous
{
operationContext.Add(OperationContextFieldName.ClientLastViewId, forcedViewId);
}
else
{
operationContext.Add(OperationContextFieldName.ClientLastViewId, cmdInfo.ClientLastViewId);
}
resultSet = nCache.Cache.Search(cmdInfo.Query, cmdInfo.Values, operationContext);
stopWatch.Stop();
SearchResponseBuilder.BuildResponse(resultSet, cmdInfo.RequestId, command.commandID, _serializedResponsePackets, cmdInfo.CommandVersion, out resultCount);
}
catch (Exception exc)
{
exception = exc.ToString();
_serializedResponsePackets.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeExceptionResponse(exc, command.requestID, command.commandID));
}
finally
{
TimeSpan executionTime = stopWatch.Elapsed;
try
{
if (Alachisoft.NCache.Management.APILogging.APILogManager.APILogManger != null && Alachisoft.NCache.Management.APILogging.APILogManager.EnableLogging)
{
APILogItemBuilder log = new APILogItemBuilder(MethodsName.Search.ToLower());
log.GenerateSearchAPILogItem(cmdInfo.Query, cmdInfo.Values, overload, exception, executionTime, clientManager.ClientID.ToLower(), clientManager.ClientSocketId.ToString(), resultCount);
}
}
catch
{
}
}
}
/// <summary>
/// Commit changes
/// </summary>
public QueryResultSet Commit()
{
ds.AcceptChanges();
QueryResultSet results = new QueryResultSet();
results.Add(new QueryResult("Commit"));
return(results);
}
/// <summary>
/// Undo changes
/// </summary>
public QueryResultSet Rollback()
{
ds.RejectChanges();
QueryResultSet results = new QueryResultSet();
results.Add(new QueryResult("Rollback"));
return(results);
}
internal void SetResult(QueryContext queryContext, AggregateFunctionType functionType, object result)
{
QueryResultSet resultSet = new QueryResultSet();
resultSet.Type = QueryType.AggregateFunction;
resultSet.AggregateFunctionType = functionType;
resultSet.AggregateFunctionResult = new DictionaryEntry(functionType, result);
queryContext.ResultSet = resultSet;
}
private void MockUserRepository_Query_ThrowsError()
{
QueryResultSet <User> userQueryResultSet = new QueryResultSet <User>
{
Success = false
};
MockUserRepositoryQueryWithUserData(userQueryResultSet);
}
private void MockUserRepository_Query_ReturnsZeroUsers()
{
QueryResultSet <User> userQueryResultSet = new QueryResultSet <User>
{
Success = true
};
MockUserRepositoryQueryWithUserData(userQueryResultSet);
}
private static QueryResultSet <Workspace> GetArtifactIdOfTemplate(IRSAPIClient proxy, string templateName)
{
var query = new Query <Workspace>();
query.Condition = new kCura.Relativity.Client.TextCondition(FieldFieldNames.Name, TextConditionEnum.EqualTo, templateName);
query.Fields = FieldValue.AllFields;
QueryResultSet <Workspace> resultSet = proxy.Repositories.Workspace.Query(query, 0);
return(resultSet);
}
public static int Create(Relativity.Client.IRSAPIClient proxy, string workspaceName, string templateName, int?serverId = null)
{
try
{
int num1 = 0;
proxy.APIOptions.WorkspaceID = -1;
if (templateName == string.Empty)
{
throw new SystemException("Template name is blank in your configuration setting. Please add a template name to create a workspace");
}
QueryResultSet <Workspace> artifactIdOfTemplate = CreateWorkspace.GetArtifactIdOfTemplate(proxy, templateName);
if (!artifactIdOfTemplate.Success)
{
return(num1);
}
int artifactId = artifactIdOfTemplate.Results.FirstOrDefault <Result <Workspace> >().Artifact.ArtifactID;
Workspace createDTO = new Workspace();
createDTO.Name = workspaceName;
int?nullable1 = serverId ?? artifactIdOfTemplate.Results.FirstOrDefault <Result <Workspace> >().Artifact.ServerID;
createDTO.ServerID = new int?(nullable1.Value);
Relativity.Client.ProcessOperationResult processOperationResult = new Relativity.Client.ProcessOperationResult();
try
{
Relativity.Client.ProcessOperationResult async = proxy.Repositories.Workspace.CreateAsync(artifactId, createDTO);
if (!async.Success)
{
throw new Exception(string.Format("workspace creation failed: {0}", (object)async.Message));
}
ProcessInformation processState = proxy.GetProcessState(proxy.APIOptions, async.ProcessID);
int num2 = 0;
while (processState.State != ProcessStateValue.Completed)
{
Thread.Sleep(10000);
processState = proxy.GetProcessState(proxy.APIOptions, async.ProcessID);
if (num2 > 6)
{
Console.WriteLine("Workspace creation timed out");
}
++num2;
}
int num3 = processState.OperationArtifactIDs.FirstOrDefault <int?>().Value;
Console.WriteLine("Workspace Created with Artiafact ID :" + (object)num3);
return(num3);
}
catch (Exception ex)
{
throw new Exception(string.Format("Unhandled Exception : {0}", (object)ex));
}
}
catch (Exception ex)
{
throw new Exception("Create Workspace failed", ex);
}
}
/// <summary>
/// Show the results on the result panel
/// </summary>
/// <param name="results"></param>
private void ShowQueryResult(QueryResultSet results)
{
flpResults.Controls.Clear();
for (int i = 0; i < results.Count; i++)
{
QueryResult result = results[i];
QueryResultsViewer v = new QueryResultsViewer(result);
flpResults.Controls.Add(v);
}
flpResults_SizeChanged(this, EventArgs.Empty);
}
public static IList BuildResponse(QueryResultSet resultSet, string RequestId, IList _serializedResponse, int commandID, Caching.Cache cache, out int resultCount)
{
Alachisoft.NCache.SocketServer.Util.KeyPackageBuilder.Cache = cache;
long requestId = Convert.ToInt64(RequestId);
resultCount = 0;
try
{
int sequenceId = 1;
Alachisoft.NCache.Common.Protobuf.SearchEntriesCQResponse searchEntriesResponse = new Alachisoft.NCache.Common.Protobuf.SearchEntriesCQResponse();
searchEntriesResponse.queryResultSet = new Alachisoft.NCache.Common.Protobuf.CQResultSet();
searchEntriesResponse.queryResultSet.CQUniqueId = resultSet.CQUniqueId;
searchEntriesResponse.queryResultSet.queryType = Alachisoft.NCache.Common.Protobuf.CQType.SEARCH_CQ_ENTRIES;
Alachisoft.NCache.Common.Protobuf.Response response = new Alachisoft.NCache.Common.Protobuf.Response();
response.requestId = requestId;
response.commandID = commandID;
response.responseType = Alachisoft.NCache.Common.Protobuf.Response.Type.SEARCH_ENTRIES_CQ;
IList keyValuesPackageChuncks = Alachisoft.NCache.SocketServer.Util.KeyPackageBuilder.PackageKeysValues(resultSet.SearchEntriesResult);
response.numberOfChuncks = keyValuesPackageChuncks.Count;
foreach (Alachisoft.NCache.Common.Protobuf.KeyValuePackageResponse package in keyValuesPackageChuncks)
{
response.sequenceId = sequenceId++;
searchEntriesResponse.queryResultSet.searchKeyEnteriesResult = package;
response.searchEntriesCQResponse = searchEntriesResponse;
_serializedResponse.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeResponse(response));
}
if (resultSet != null && resultSet.SearchEntriesResult != null)
{
resultCount = resultSet.SearchEntriesResult.Count;
}
}
catch (Exception ex)
{
if (SocketServer.Logger.IsErrorLogsEnabled)
{
SocketServer.Logger.NCacheLog.Error(ex.ToString());
if (resultSet == null)
{
SocketServer.Logger.NCacheLog.Error("QueryResultSet is null");
}
}
}
return(_serializedResponse);
}
public QueryResultSet<DAL.ResponseModel.AddressResponse> GetAddresses()
{
List<AddressResponse> addressResponseList = new List<AddressResponse>();
QueryResultSet<AddressResponse> resultSet = new QueryResultSet<AddressResponse>();
try
{
int addressStatus = Convert.ToInt32(Enums.AddressStatus.Active);
var items = new AddressServices().dbContext.Address.Where(x => x.Status == addressStatus).ToList();
if(items.Count >0)
{
foreach(var item in items)
{
var itemResponse = new AddressServices().ToModelResponse(item);
addressResponseList.Add(itemResponse);
}
resultSet.IsResult = true;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = addressResponseList;
}
else
{
resultSet.IsOperationSuccessful = true;
resultSet.IsResult = false;
resultSet.ResultSet = null;
}
}
catch(Exception ex)
{
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
}
return resultSet;
}
public QueryResultSet<ServiceResponse> GetAllServices(string st)
{
int serviceStatus = -1;
List<ServiceDetails> serviceDetailsList = null;
List<ServiceResponse> serviceResponseList = new List<ServiceResponse>();
QueryResultSet<ServiceResponse> resultSet = new QueryResultSet<ServiceResponse>();
try
{
if (string.IsNullOrEmpty(st))
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Session Token is empty" });
resultSet.InfoMessages = err;
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
return resultSet;
}
if (!SessionHelper.IsValidSession(st))
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Invalid Session Token" });
resultSet.InfoMessages = err;
resultSet.IsOperationSuccessful = false;
resultSet.IsResult = false;
resultSet.ResultSet = null;
return resultSet;
}
using (var owlsService = new OwlsService())
{
serviceStatus = Convert.ToInt32(Enums.ServiceStatus.Active);
var serviceItems = owlsService.dbContext.Service.Where(x => x.Status == serviceStatus).ToList();
if (serviceItems.Count > 0)
{
serviceDetailsList = new List<ServiceDetails>();
foreach(Service service in serviceItems)
{
serviceDetailsList = new ServiceDetailService().dbContext.ServiceDetails.Where(x =>x.ServiceId == service.Id && x.Status == serviceStatus).ToList();
var serviceResponse = owlsService.ToModelResponse(service, serviceDetailsList);
if (serviceResponse != null)
{
serviceResponseList.Add(serviceResponse);
}
}
resultSet.IsResult = true;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = serviceResponseList;
}
else
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = "Service list is empty" });
resultSet.InfoMessages = err;
resultSet.IsResult = false;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = null;
}
}
}
catch(Exception ex)
{
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.ErrorMessage), Text = ex.Message });
resultSet.ErrorMessages = err;
resultSet.IsResult = false;
resultSet.IsOperationSuccessful = true;
resultSet.ResultSet = null;
}
return resultSet;
}
