/// <summary>
/// 3 获取某种测试的试剂类型列表
/// </summary>
/// <param name="testTypeTag">测试类型编号</param>
/// <returns></returns>
public List<SimpleRowInfo> HRTestParms(int testTypeTag)
{
var condition = new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, testTypeTag, 0, 0);
QueryArgs q = new QueryArgs("HRTestParms", condition, "ProcTag", "ProcID");
return GetSimpleRowInfos(q);
}
public override void AfterPopulateProperties(HookContext context)
{
var dataSource = Activator.CreateInstance(DataSourceType);
var dataSourceCollectionProperty = DataSourceType.GetProperty(context.Property.Name);
IEnumerable dataSourceCollection = (IEnumerable)dataSourceCollectionProperty.GetValue(dataSource, null);
QueryArgs queryArgs = new QueryArgs()
{
ReturnType = dataSourceCollectionProperty.PropertyType.GetGenericArguments()[0].FullName,
};
var argObject = context.Args;
var argType = context.Property.DeclaringType;
if (argType.GetProperty("Skip") != null)
{
queryArgs.Skip = (int)argType.GetProperty("Skip").GetValue(argObject, null);
}
if (argType.GetProperty("Take") != null)
{
var take = (int)argType.GetProperty("Take").GetValue(argObject, null);
if (take > 0) queryArgs.Take = take;
}
if (argType.GetProperty("Where") != null)
{
queryArgs.Where = argType.GetProperty("Where").GetValue(argObject, null) as string;
}
if (argType.GetProperty("OrderBy") != null)
{
var orderProp = argType.GetProperty("OrderBy").GetValue(argObject, null) as string;
if (string.IsNullOrEmpty(orderProp) == false)
{
queryArgs.OrderBy = "item => " + orderProp;
}
}
if (argType.GetProperty("OrderByDescending") != null)
{
var orderProp = argType.GetProperty("OrderByDescending").GetValue(argObject, null) as string;
if (string.IsNullOrEmpty(orderProp) == false)
{
queryArgs.OrderByDescending = "item => " + orderProp;
}
}
if (referencedAssemblies != null)
{
queryArgs.ReferencedAssemblies.AddRange(referencedAssemblies);
}
var results = queryArgs.RunQuery(dataSourceCollection);
context.Property.SetValue(context.Args, results, null);
}
public void PointSearchWithNoBufferFindsNothing()
{
const string featureClass = "SGID10.ELEVATION.HighestPeaks";
var args = new QueryArgs(featureClass, "point:[445190.8,4471328.55]", new[] {"NAME"}, "");
var client = new HttpClient();
var url = "http://localhost:6080/arcgis/rest/services/Soe/SearchApi/MapServer/exts/Search/Search?{0}&f=json"
.With(args.ToQueryString());
var response = client.GetAsync(url);
var result = response.Result.Content.ReadAsStringAsync().Result;
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.StringStarting("{\"Results\":[]").IgnoreCase);
}
public void ReturnsErrorWhenFeatureClassDoesNotExist()
{
const string featureClass = "SGID93.Schema.Fake";
var args = new QueryArgs(featureClass, "", new[] {"name"}, "");
var client = new HttpClient();
var url =
"http://localhost:6080/arcgis/rest/services/Soe/SearchApi/MapServer/exts/Search/Search?{0}&f=json".
With(args.ToQueryString());
var response = client.GetAsync(url);
var result = response.Result.Content.ReadAsStringAsync().Result;
Assert.That(result, Is.Not.Null);
Assert.That(result,
Is.EqualTo("{\"error\":{\"code\":400,\"message\":\"DBMS table not found\"}}").IgnoreCase);
}
public void SpatialQueryDatabaseForAttribute()
{
const string featureClass = "SGID93.BOUNDARIES.Counties";
var args = new QueryArgs(featureClass, "point:[314755, 4609130]", new[] {"NAME"}, "");
var client = new HttpClient();
var url =
"http://localhost:6080/arcgis/rest/services/Soe/SearchApi/MapServer/exts/Search/Search?{0}&f=json".
With(args.ToQueryString());
var response = client.GetAsync(url);
var result = response.Result.Content.ReadAsStringAsync().Result;
Assert.That(result, Is.Not.Null);
Assert.That(result,
Is.StringStarting(
"{\"Results\":[{\"Geometry\":null,\"Attributes\":{\"Name\":\"Box Elder\"}}]").IgnoreCase);
}
/// <summary>
/// When overridden in the derived class, sets the database parameters values <paramref name="p"/>
/// based on the values specified in the given <paramref name="item"/> parameter.
/// </summary>
/// <param name="p">Collection of database parameters to set the values for.</param>
/// <param name="item">The value or object/struct containing the values used to execute the query.</param>
protected override void SetParameters(DbParameterValues p, QueryArgs item)
{
p["charID"] = (int)item.CharacterID;
p["questID"] = (int)item.QuestID;
}
public override void AddArg(QueryArgs args)
{
}
protected override void Query(QueryArgs args, QueryResult result)
{
var navigateId = this.ComponentOwner <PageAdminLoginUser>().GridLoginUser.RowSelect.Id;
result.Query = args.Query.Where(item => item.LoginUserId == navigateId);
}
/// <summary>
/// 获取简单行信息列表
/// </summary>
/// <param name="q">查询参数</param>
/// <returns></returns>
private List <SimpleRowInfo> GetSimpleRowInfos(QueryArgs q)
{
return(GetSimpleRowInfos(q, true));
}
public override async Task InitNdmExtension(NdmExtension request, IServerStreamWriter <NdmQuery> responseStream,
ServerCallContext context)
{
var peer = context.Peer;
if (_logger.IsInfo)
{
_logger.Info($"Received InitNdmExtension() GRPC call from peer: '{peer}'. Extension: '{request.Name}', type: '{request.Type}', accept all headers: {request.AcceptAllHeaders}, accepted headers: {request.AcceptedHeaders}.");
}
if (string.IsNullOrWhiteSpace(request.Name) || string.IsNullOrWhiteSpace(request.Type))
{
if (_logger.IsWarn)
{
_logger.Warn($"Extension name and type cannot be empty.");
}
return;
}
var extension = _ndmExtensions.AddOrUpdate(request.Name.ToLowerInvariant(),
_ => new NdmExtensionDetails(request),
(_, e) => e);
extension.Connect();
try
{
var acceptedHeaders = request.AcceptedHeaders?.Where(h => !string.IsNullOrEmpty(h))
.Select(h => new Keccak(h)) ?? Enumerable.Empty <Keccak>();
foreach (var headerId in acceptedHeaders)
{
_dataHeadersExtensions.TryAdd(headerId, extension);
}
}
catch (Exception ex)
{
if (_logger.IsError)
{
_logger.Error($"Received an invalid header ID from peer: '{peer}'", ex);
}
return;
}
QueryArgs query = null;
try
{
while (true)
{
query = extension.Queries.Take();
if (_logger.IsTrace)
{
_logger.Trace($"Sending query for header: '{query.HeaderId}', deposit: '{query.DepositId}', args: {string.Join(", ", query.Args)}, iterations: {query.Iterations}");
}
await responseStream.WriteAsync(new NdmQuery
{
Iterations = query.Iterations,
HeaderId = query.HeaderId.ToString(),
DepositId = query.DepositId.ToString(),
Args = { query.Args }
});
}
}
catch (Exception ex)
{
if (_logger.IsError)
{
_logger.Error(ex.ToString(), ex);
}
if (!(query is null))
{
extension.Queries.Add(query);
if (_logger.IsInfo)
{
_logger.Info($"Queued again query for header: '{query.HeaderId}', deposit: '{query.DepositId}'.");
}
}
}
if (_logger.IsInfo)
{
_logger.Info($"Finished using an extension: '{request.Name}' [{request.Type}].");
}
}
private static Task <IEnumerable <T> > ToListAsync <T>(IEnumerable <T> col, Func <T, bool> predicate, QueryArgs q, CancellationToken cancellationToken = default) where T : BaseResourceEntity
{
cancellationToken.ThrowIfCancellationRequested();
return(Task.Run(() =>
{
if (q == null)
{
return col;
}
col = q.NameExactly ? col.Where(ele => ele.Name == q.NameQuery) : col.Where(ele => ele.Name?.Contains(q.NameQuery) == true);
if (predicate != null)
{
col = col.Where(predicate);
}
return col.Where(ele => ele.State == q.State).Skip(q.Offset).Take(q.Count);
}));
}
private int GetResultInfos(QueryArgs q, bool useIndex)
{
List<string> primIDs = new List<string>();
_ResultDataSet = new DataSet("ResultDataSet");
var rdr = _Connection.ExecuteQuery(q.TableName, q.Condition, useIndex);
DataTable reportTable = CreateReportTable(rdr, "Report", _ResultDataSet);
while (rdr.Read())
{
// 初始化数据记录
DataRow row = reportTable.NewRow();
for (int i = 0; i < rdr.FieldCount; i++)
{
row[i] = rdr[i];
}
reportTable.Rows.Add(row);
// 保存病人ID
primIDs.Add((string)rdr["PrimID"]);
// 创建曲线点信息
if (OnAddCurve != null)
{
string label = "Channel " + rdr["ChnlNum"].ToString();
AggRamCurve crv = new AggRamCurve(
label,
(int)rdr["InitialMax"], (int)rdr["InitialMin"],
(int)rdr["ScaleSet1Rd"], (int)rdr["MaxPCPoint"], (double)rdr["ScaleSetResult"],
(int)rdr["DataPoints"], (byte[])rdr["Data"]);
OnAddCurve(label, crv);
//OnAddCurve(label, CreateCurve((int)rdr["DataPoints"], (byte[])rdr["Data"]));
}
}
_ResultDataSet.Tables.Add(CreatePatientsTable(primIDs));
return primIDs.Count;
}
/// <summary>
/// When overridden in the derived class, sets the database parameters values <paramref name="p"/>
/// based on the values specified in the given <paramref name="item"/> parameter.
/// </summary>
/// <param name="p">Collection of database parameters to set the values for.</param>
/// <param name="item">The value or object/struct containing the values used to execute the query.</param>
protected override void SetParameters(DbParameterValues p, QueryArgs item)
{
p["id"] = (int)item.ID;
p["tag"] = item.Value;
}
public async Task <IActionResult> GetOffersForCity(string city, [FromQuery] QueryArgs query)
{
var result = await _mediator.Send(new GetOffersQuery(query, city));
return(result.Process());
}
public void OnMatchTimeout(QueryArgs queryArgs)
{
m_OnMatchTimeout.Invoke(queryArgs);
}
protected virtual string FormatLog(string type, string content, QueryArgs queryArgs)
{
var Time = DateTime.Now;
var log = new StringBuilder(Log_Prefix);
log.Replace("{time}", (Time.Ticks / 1000).ToString());
log.Replace("{yyyy}", Time.Year.ToString());
log.Replace("{yy}", (Time.Year % 100).ToString("D2"));
log.Replace("{MM}", Time.Month.ToString("D2"));
log.Replace("{dd}", Time.Day.ToString("D2"));
log.Replace("{HH}", Time.Hour.ToString("D2"));
log.Replace("{hh}", Time.Hour.ToString("D2"));
log.Replace("{mm}", Time.Minute.ToString("D2"));
log.Replace("{ss}", Time.Second.ToString("D2"));
log.Replace("{type}", type);
if (Log_Prefix.Contains("{class}") || Log_Prefix.Contains("{method}"))
{
var mi = GetMethodInfo();
log.Replace("{class}", mi.DeclaringType.FullName);
log.Replace("{method}", mi.Name);
}
log.Replace("{threadId}", Thread.CurrentThread.ManagedThreadId.ToString());
if (queryArgs != null)
{
if (string.IsNullOrEmpty(queryArgs.BatchNum) == false)
{
log.Insert(0, queryArgs.BatchNum + "|");
}
if (queryArgs.HttpContext != null)
{
var ip = queryArgs.HttpContext.GetRealIP();
var request = queryArgs.HttpContext.Request;
log.Append($"{ip}|{request.Method}|{request.Scheme}://{request.Host}{request.Path}{request.QueryString}\r\n");
if (request.Method == "POST")
{
if (request.ContentType.ToLower().StartsWith("multipart/form-data;") == false || request.ContentType.ToLower().Contains("json") == false)
{
try {
using (var buffer = new MemoryStream()) {
//request.EnableRewind();
request.Body.Position = 0;
request.Body.CopyTo(buffer);
request.Body.Position = 0;
var bs = buffer.ToArray();
var post = Encoding.UTF8.GetString(bs);
log.Append("Body:" + post + "\r\n");
}
} catch { }
}
}
}
}
if (string.IsNullOrEmpty(content) == false)
{
log.Append(content);
}
log.Append("\r\n\r\n");
return(log.ToString());
}
/// <summary>
/// When overridden in the derived class, sets the database parameters values <paramref name="p"/>
/// based on the values specified in the given <paramref name="item"/> parameter.
/// </summary>
/// <param name="p">Collection of database parameters to set the values for.</param>
/// <param name="item">The value or object/struct containing the values used to execute the query.</param>
protected override void SetParameters(DbParameterValues p, QueryArgs item)
{
p["charID"] = (int)item.CharacterID;
p["guildID"] = (int)item.GuildID;
p["rank"] = (byte)item.Rank;
}
public IActionResult Get([FromQuery] QueryArgs queryArgs)
{
try
{
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
//查询条件
FilterDefinition <BsonDocument> filter = FilterDefinition <BsonDocument> .Empty;
//【SingleObject,TableList,Count】预处理一些逻辑
if (new InterfaceType[] { InterfaceType.SingleObject, InterfaceType.TableList, InterfaceType.Count }.Contains(queryContext.InterfaceType))
{
//缓存对象下的全部未删除字段信息
queryContext.MetaFieldsUnDeleted = metaFieldService.GetEntitiesUnDeletedByMetaObjectId(queryContext.MetaObjectId);
//组织查询条件
filter = conditionAggregationService.AnalysisConditionToFilterDefinitionByConditionId(queryContext, queryContext.ArgumentsDic);
//缓存列字段信息
if (queryContext.InterfaceType == InterfaceType.SingleObject || queryContext.InterfaceType == InterfaceType.TableList)
{
queryContext.FieldListMetaFieldsOfFieldListId = _fieldListMetaFieldService.GetByFieldListId(queryContext.FieldListId);
}
}
switch (queryContext.InterfaceType)
{
case InterfaceType.SingleObject:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_SingleObject);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_SingleObject_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var singleObjectComponent = dataAccessService.GetSingleObjectComponent(queryContext, filter);
singleObjectComponent = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_SingleObject_After, singleObjectComponent, CurrentApplicationContext, queryContext.InterfaceCode, singleObjectComponent);
return(JsonResultModel.Success("get single data success", singleObjectComponent));
case InterfaceType.TableList:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_TableList);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_TableList_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var sort = metaFieldService.GetSortDefinitionBySortFields(queryContext, new[] { new SortField {
Column = "ModifyTime", IsDesc = true
} });
var tableListComponent = dataAccessService.GetTableListComponent(queryContext, filter, queryArgs._pageIndex, queryArgs._pageSize, sort, out int totalCount);
tableListComponent = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_TableList_After, tableListComponent, CurrentApplicationContext, queryContext.InterfaceCode, tableListComponent);
return(JsonResultModel.Success("get data list success", tableListComponent));
case InterfaceType.Count:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_Count);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_Count_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var count = dataAccessService.GetCount(queryContext.TenantId, queryContext.MetaObjectId, filter);
count = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_Count_After, count, CurrentApplicationContext, queryContext.InterfaceCode, filter, count);
return(JsonResultModel.Success("get data count success", count));
case InterfaceType.JsonDataSource:
return(new JsonResult(Newtonsoft.Json.JsonConvert.DeserializeObject(_dataSourceService.GetById(queryContext.DataSourceId).Script)));
case InterfaceType.ExecutableScriptDataSource:
object triggerScriptDataSourceResult = _triggerScriptService.RunDataSourceScript(queryContext, CurrentApplicationContext, queryContext.InterfaceCode, queryContext.ArgumentsDic);
return(JsonResultModel.Success("get trigger script result success", triggerScriptDataSourceResult));
default:
break;
}
return(JsonResultModel.Success("success,no data"));
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
public int GetCurves(string primID, int crvSeqNo, string worklistID, int worklistNumber)
{
if (crvSeqNo > 0)
{
//var condition = new ParadoxCondition.Compare(ParadoxCompareOperator.Equal, mainTestID, 8, 0);
//QueryArgs q = new QueryArgs("HRRuns", condition, "CrvSeqNum", "");
//return GetSimpleRowInfos(q, false);
}
if (!String.IsNullOrEmpty(primID))
{ }
if (!String.IsNullOrEmpty(worklistID) && worklistNumber > 0)
{
var condition =
new ParadoxCondition.LogicalAnd(
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, worklistID, 4, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, worklistNumber, 0, 0)
);
QueryArgs q = new QueryArgs("HRRuns", condition, "", "");
return GetResultInfos(q, false);
}
return 0;
}
/// <summary>
/// 获取简单行信息列表
/// </summary>
/// <param name="q">查询参数</param>
/// <param name="useIndex">是否使用索引</param>
/// <returns></returns>
private List<SimpleRowInfo> GetSimpleRowInfos(QueryArgs q, bool useIndex)
{
List<SimpleRowInfo> results = new List<SimpleRowInfo>();
var rdr = _Connection.ExecuteQuery(q.TableName, q.Condition, useIndex);
while (rdr.Read())
{
SimpleRowInfo testType = new SimpleRowInfo();
if (!String.IsNullOrEmpty(q.TagName))
{
testType.Tag = (int)rdr[q.TagName];
}
if (!String.IsNullOrEmpty(q.IDName))
{
testType.ID = rdr[q.IDName].ToString();
}
results.Add(testType);
}
return results;
}
/// <summary>
/// Searches.
/// </summary>
/// <param name="q">The query arguments.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>A collection of entity.</returns>
public virtual async Task <CollectionResult <TEntity> > SearchAsync(QueryArgs q, CancellationToken cancellationToken = default)
{
var set = await GetDbSetAsync();
return(new CollectionResult <TEntity>(await set.ListEntities(q).ToListAsync(cancellationToken), q?.Offset ?? 0));
}
/// <summary>
/// 4 获取Worklist列表
/// </summary>
/// <param name="testTypeTag"></param>
/// <param name="mainRunType"></param>
/// <param name="mainTestID"></param>
/// <returns></returns>
public List<SimpleRowInfo> HRWorkLists(int testTypeTag, int mainRunType, int procTag, bool useMainTest)
{
int dataIndex = useMainTest ? 9 : 8;
var condition =
new ParadoxCondition.LogicalAnd(
new ParadoxCondition.Compare(
ParadoxCompareOperator.Greater, 0, 0, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, testTypeTag, 7, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, (short)mainRunType, 5, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, procTag, dataIndex, 0)
);
QueryArgs q = new QueryArgs("HRRuns", condition, "WrkLstNum", "WrkLstID");
return GetSimpleRowInfos(q, false);
}
public void OnMatchTimeout(QueryArgs queryArgs)
{
ToggleDependents(false);
}
/// <summary>
/// Tries to execute the query to create an account.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="password">The password.</param>
/// <param name="email">The email.</param>
/// <param name="ip">The IP address.</param>
/// <returns>True if the account was successfully created; otherwise false.</returns>
public bool TryExecute(string name, string password, string email, uint ip)
{
if (!GameData.AccountName.IsValid(name))
{
return(false);
}
if (!GameData.AccountPassword.IsValid(password))
{
return(false);
}
if (!GameData.AccountEmail.IsValid(email))
{
return(false);
}
bool success;
password = UserAccountManager.EncodePassword(password);
var queryArgs = new QueryArgs(name, password, email, ip);
try
{
using (var r = ExecuteReader(queryArgs))
{
switch (r.RecordsAffected)
{
case 0:
success = false;
break;
case 1:
success = true;
break;
default:
success = true;
Debug.Fail("How was there more than one affected row!?");
break;
}
}
}
catch (MySqlException ex)
{
switch (ex.Number)
{
case 1062:
// Duplicate key
break;
default:
const string errmsg = "Failed to execute query. Exception: {0}";
if (log.IsErrorEnabled)
{
log.ErrorFormat(errmsg, ex);
}
Debug.Fail(string.Format(errmsg, ex));
break;
}
success = false;
}
return(success);
}
private static async Task <QueryState <T> > WhereAndOrderBy <T>(IQueryable <T> query, QueryArgs args)
{
IQueryable <T> plain;
plain = query = query.Where(args);
int count = await query.CountAsync();
query = query.OrderBy(args).Page(args);
return(new QueryState <T> {
Count = count, Final = query, Plain = plain
});
}
/// <summary>
/// Registers to get event(s) from the MARS backend
/// Allows a user to specify a custom query ID to use - make sure it is unique!
/// </summary>
/// <param name="caller">The object making the query</param>
/// <param name="queryMatchID">The identifier to use for this query</param>
/// <param name="queryArgs">The different specified data requirements we are querying for</param>
public static void RegisterQuery(this IUsesQueryResults caller, QueryMatchID queryMatchID, QueryArgs queryArgs)
{
IUsesDevQueryResultsMethods.RegisterOverrideQuery(queryMatchID, queryArgs);
}
public static async Task <PagedResult <T> > PagedResultAsync <T>(this IQueryable <T> query, QueryArgs args)
{
var state = await WhereAndOrderBy(query, args);
WriteSQL(state.Final);
return(PagedResult <T> .Create(await state.Final.ToArrayAsync(), args, state.Count, state.Plain));
}
/// <summary>
/// Lists the publish content comments.
/// </summary>
/// <param name="content">The owner content comment identifier.</param>
/// <param name="plain">true if returns from all in plain mode; otherwise, false.</param>
/// <param name="q">The optional query arguments.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>The entity list.</returns>
public Task <IEnumerable <ContentCommentEntity> > ListContentCommentsAsync(string content, bool plain, QueryArgs q, CancellationToken cancellationToken = default)
{
var col = contentComments.Where(ele => ele.OwnerId == content);
if (!plain)
{
col = col.Where(ele => string.IsNullOrWhiteSpace(ele.ParentId));
}
col = col.OrderByDescending(ele => ele.LastModificationTime);
return(ToListAsync(col, null, q, cancellationToken));
}
public static Task <PagedResult <TResult> > PagedResultByResultAsync <TSource, TResult>(this IQueryable <TSource> query, QueryArgs args)
{
return(PagedResultByResultAsync <TSource, TResult>(query, args, null));
}
public Query(IQueryArgs QArgs)
{
this.mArgs = QArgs as QueryArgs;
}
public static async Task <PagedResult <TResult> > PagedResultByResultAsync <TSource, TResult>(this IQueryable <TSource> query, QueryArgs args, ModelConvertOptions options)
{
IQueryable <TResult> query1;
query1 = query.Convert <TSource, TResult>(options);
var state = await WhereAndOrderBy(query1, args);
query1 = state.Final;
WriteSQL(query1);
return(PagedResult <TResult> .Create(await query1.ToArrayAsync(), args, state.Count, state.Plain));
}
public NonSpatialQueryCommand(IFeatureWorkspace featureWorkspace, QueryArgs args)
{
FeatureWorkspace = featureWorkspace;
Args = args;
}
public static async Task <T[]> ToArrayAsync <T>(this IQueryable <T> query, QueryArgs args)
{
var result = await query.PagedResultAsync(args);
return(result.Items);
}
/// <summary>
/// 获取Curve Sequence Number列表
/// </summary>
public List<SimpleRowInfo> CrvSeqNos(int testTypeTag, int mainRunType, string mainTestID)
{
var condition =
new ParadoxCondition.LogicalAnd(
new ParadoxCondition.Compare(
ParadoxCompareOperator.Greater, 0, 0, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, testTypeTag, 7, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, (short)mainRunType, 5, 0),
new ParadoxCondition.Compare(
ParadoxCompareOperator.Equal, mainTestID, 8, 0)
);
QueryArgs q = new QueryArgs("HRRuns", condition, "CrvSeqNum", "");
return GetSimpleRowInfos(q, false);
}
public void ConvertToqueryString()
{
var args = new QueryArgs("test", new[] { "a", "b" }, "me");
Assert.That(args.ToQueryString(), Is.EqualTo("featureClass=test&returnValues=a%2Cb&predicate=me"));
}
/// <summary>
/// 获取简单行信息列表
/// </summary>
/// <param name="q">查询参数</param>
/// <returns></returns>
private List<SimpleRowInfo> GetSimpleRowInfos(QueryArgs q)
{
return GetSimpleRowInfos(q, true);
}
public void SpatialQueryDatabaseWithWhereClause()
{
const string featureClass = "SGID93.Boundaries.Counties";
var args = new QueryArgs(featureClass, "point:[314755, 4609130]", new[] {"NAME, FIPS"},
"name = 'not found'");
var client = new HttpClient();
var url =
"http://localhost:6080/arcgis/rest/services/Soe/SearchApi/MapServer/exts/Search/Search?{0}&f=json".
With(args.ToQueryString());
var response = client.GetAsync(url);
var result = response.Result.Content.ReadAsStringAsync().Result;
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.StringStarting("{\"Results\":[]").IgnoreCase);
}
/// <summary>
/// 获取测试参数名称
/// </summary>
/// <param name="q"></param>
/// <param name="useIndex"></param>
/// <returns></returns>
private List<TestParmNameInfo> GetTestParmNames(QueryArgs q)
{
List<TestParmNameInfo> results = new List<TestParmNameInfo>();
var rdr = _Connection.ExecuteQuery(q.TableName, q.Condition);
while (rdr.Read())
{
TestParmNameInfo tstPrmNameInfo = new TestParmNameInfo();
tstPrmNameInfo.MTest = (int)rdr["MTest"];
tstPrmNameInfo.RunType = (int)rdr["RunType"];
tstPrmNameInfo.OrderNum = (int)rdr["OrderNum"];
tstPrmNameInfo.ParmType = (int)rdr["ParmType"];
tstPrmNameInfo.ParmName = (string)rdr["ParmName"];
results.Add(tstPrmNameInfo);
}
return results;
}
/// <summary>
/// When overridden in the derived class, sets the database parameters values <paramref name="p"/>
/// based on the values specified in the given <paramref name="item"/> parameter.
/// </summary>
/// <param name="p">Collection of database parameters to set the values for.</param>
/// <param name="item">The value or object/struct containing the values used to execute the query.</param>
protected override void SetParameters(DbParameterValues p, QueryArgs item)
{
p["ip"] = item.IP;
p["id"] = item.AccountID;
}
/// <summary>
/// Lists the revision entities.
/// </summary>
/// <param name="source">The source owner identifier.</param>
/// <param name="q">The optional query arguments.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>The entity list.</returns>
public Task <IEnumerable <ContentTemplateRevisionEntity> > ListContentTemplateRevisionAsync(string source, QueryArgs q = null, CancellationToken cancellationToken = default)
{
return(ToListAsync(contentTemplateRevisions, ele => ele.SourceId == source, q, cancellationToken));
}
/// <summary>
/// Lists the publish content templates.
/// </summary>
/// <param name="siteId">The owner site identifier.</param>
/// <param name="q">The optional query arguments.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>The entity list.</returns>
public Task <IEnumerable <ContentTemplateEntity> > ListContentTemplateAsync(string siteId, QueryArgs q = null, CancellationToken cancellationToken = default)
{
return(ToListAsync(contentTemplates, ele => ele.OwnerSiteId == siteId, q, cancellationToken));
}
public GetOffersQuery(QueryArgs paging, string city = null)
{
Paging = paging;
City = city;
}
/// <summary>
/// Lists the child comments of a specific publish content comment.
/// </summary>
/// <param name="id">The parent identifier of the content comment.</param>
/// <param name="q">The optional query arguments.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>The entity list.</returns>
public Task <IEnumerable <ContentCommentEntity> > ListContentChildCommentsAsync(string id, QueryArgs q, CancellationToken cancellationToken = default)
{
var col = contentComments.Where(ele => ele.SourceMessageId == id);
col = col.OrderByDescending(ele => ele.LastModificationTime);
return(ToListAsync(col, null, q, cancellationToken));
}
public LeanKitQuery(QueryArgs queryArgs)
{
_args = queryArgs;
}
// private methods
private void _do_query(YouTubeQuery q)
{
if (_query_thread.IsBusy)
return;
QueryArgs qa = new QueryArgs();
qa.Query = q;
qa.Service = _yt_service;
_query_thread.RunWorkerAsync(qa);
}
